@mduan/paseo-cli 0.11.0-fork.1 → 0.11.0-fork.3

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -11,8 +11,10 @@ import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { composeSystemPromptParts } from "../system-prompt.js";
 import { curateAgentActivity } from "../activity-curator.js";
 import { CodexAsyncQuestions, codexAsyncQuestionToTimeline } from "./codex/async-questions.js";
-import { CodexPriceList } from "./codex/pricing.js";
+import { getSharedCodexPriceList } from "./codex/pricing.js";
 import { CodexRolloutCost } from "./codex/rollout-cost.js";
+import { rollupProviderSubagentCosts } from "../provider-subagents/cost.js";
+import { formatSubagentCosts, formatSubagentTokens, } from "../provider-subagents/subtitle-format.js";
 import { mapCodexToolCallEnvelope, mapCodexToolCallFromThreadItem, normalizeCommandExecutionCommand, splitCodexMcpToolResultImages, } from "./codex/tool-call-mapper.js";
 import { checkProviderLaunchAvailable, createProviderEnv, createProviderEnvSpec, resolveProviderLaunch, } from "../provider-launch-config.js";
 import { findExecutable, probeExecutable, } from "../../../executable-resolution/executable-resolution.js";
@@ -723,12 +725,6 @@ function filterCodexThreadsByCwd(threads, cwd) {
     const belongsToWorkspace = createPathEquivalenceMatcher(cwd);
     return threads.filter((thread) => typeof thread.cwd === "string" && belongsToWorkspace(thread.cwd));
 }
-let sharedCodexPriceList;
-// One price list per daemon, so every Codex session and custom Codex provider shares one fetch.
-function getSharedCodexPriceList(logger) {
-    sharedCodexPriceList ?? (sharedCodexPriceList = new CodexPriceList({ logger }));
-    return sharedCodexPriceList;
-}
 var CodexCostStatus;
 (function (CodexCostStatus) {
     /** No priced request yet, an unpriced model, or no rollout file. */
@@ -750,16 +746,34 @@ function isSameCostEstimate(left, right) {
     }
     return left.status === right.status;
 }
-// Both cost fields are always written, undefined included, so the agent manager's usage merge on
+// All cost fields are always written, undefined included, so the agent manager's usage merge on
 // turn completion cannot keep a stale value from the previous state.
-function withCostEstimate(usage, estimate) {
+function withCostEstimate(usage, estimate, subagentCostUsd) {
     switch (estimate.status) {
         case CodexCostStatus.Estimated:
-            return { ...usage, totalCostUsd: estimate.costUsd, totalCostUnavailable: false };
+            return {
+                ...usage,
+                ...(subagentCostUsd > 0 ? { subagentCostUsd } : { subagentCostUsd: undefined }),
+                totalCostUsd: estimate.costUsd + subagentCostUsd,
+                totalCostUnavailable: false,
+                totalCostEstimated: true,
+            };
         case CodexCostStatus.Unavailable:
-            return { ...usage, totalCostUsd: undefined, totalCostUnavailable: true };
+            return {
+                ...usage,
+                subagentCostUsd: undefined,
+                totalCostUsd: undefined,
+                totalCostUnavailable: true,
+                totalCostEstimated: undefined,
+            };
         case CodexCostStatus.Pending:
-            return { ...usage, totalCostUsd: undefined, totalCostUnavailable: undefined };
+            return {
+                ...usage,
+                subagentCostUsd: undefined,
+                totalCostUsd: undefined,
+                totalCostUnavailable: undefined,
+                totalCostEstimated: undefined,
+            };
     }
 }
 export function toAgentUsage(tokenUsage) {
@@ -2598,6 +2612,7 @@ export class CodexAppServerAgentSession {
         this.emittedProviderSubagentUserMessageKeys = new Set();
         this.subAgentCallsByCallId = new Map();
         this.subAgentCallIdByChildThreadId = new Map();
+        this.subAgentUsageByThreadId = new Map();
         this.pendingSubAgentNotificationsByThreadId = new Map();
         this.warnedUnknownNotificationMethods = new Set();
         this.warnedInvalidNotificationPayloads = new Set();
@@ -3000,6 +3015,7 @@ export class CodexAppServerAgentSession {
         const { timeline, subAgentRoutes } = history;
         this.subAgentCallsByCallId.clear();
         this.subAgentCallIdByChildThreadId.clear();
+        this.subAgentUsageByThreadId.clear();
         this.pendingSubAgentNotificationsByThreadId.clear();
         this.persistedProviderSubagentEvents = [];
         this.loadingPersistedHistory = true;
@@ -3041,6 +3057,9 @@ export class CodexAppServerAgentSession {
                 parentSubagentId: next.parentSubagentId,
             });
             try {
+                const usage = {};
+                this.subAgentUsageByThreadId.set(next.route.childThreadId, usage);
+                await this.refreshSubAgentCost(next.route.childThreadId, usage, client);
                 const childHistory = await loadCodexThreadHistoryTimeline({
                     threadId: next.route.childThreadId,
                     cwd: this.config.cwd ?? null,
@@ -4271,6 +4290,9 @@ export class CodexAppServerAgentSession {
     }
     dispatchSubAgentNotification(parsed, callId) {
         switch (parsed.kind) {
+            case "token_usage_updated":
+                this.handleSubAgentTokenUsage(parsed);
+                return;
             case "thread_started":
                 this.emitSubAgentActivityUpdate(callId, "running", { reopen: true });
                 return;
@@ -4937,7 +4959,10 @@ export class CodexAppServerAgentSession {
     }
     handleTokenUsageUpdatedNotification(parsed) {
         const usage = toAgentUsage(parsed.tokenUsage);
-        this.latestUsage = usage ? withCostEstimate(usage, this.costEstimate) : undefined;
+        const subagentCostUsd = this.subagentCostRollup().totalCostUsd;
+        this.latestUsage = usage
+            ? withCostEstimate(usage, this.costEstimate, subagentCostUsd)
+            : undefined;
         if (this.latestUsage) {
             this.notifySubscribers({
                 type: "usage_updated",
@@ -4947,6 +4972,83 @@ export class CodexAppServerAgentSession {
         }
         void this.refreshRolloutCost();
     }
+    handleSubAgentTokenUsage(parsed) {
+        const threadId = parsed.threadId;
+        if (!threadId)
+            return;
+        let usage = this.subAgentUsageByThreadId.get(threadId);
+        if (!usage) {
+            usage = {};
+            this.subAgentUsageByThreadId.set(threadId, usage);
+        }
+        // The last request's context, which is what the Claude subagent rows report as tokens too.
+        usage.tokens = toAgentUsage(parsed.tokenUsage)?.contextWindowUsedTokens;
+        this.emitSubAgentSubtitle(threadId, usage);
+        void this.refreshSubAgentCost(threadId, usage);
+    }
+    async refreshSubAgentCost(threadId, usage, client = this.client) {
+        const priceList = this.deps.codexPriceList;
+        if (!priceList)
+            return;
+        try {
+            usage.rolloutCost ?? (usage.rolloutCost = this.openRolloutCost(threadId, client));
+            const rolloutCost = await usage.rolloutCost;
+            const prices = await priceList.get();
+            if (!rolloutCost || !prices)
+                return;
+            usage.costUsd = await rolloutCost.read({ prices, serviceTier: this.serviceTier });
+            usage.model = rolloutCost.model;
+            if (this.subAgentUsageByThreadId.get(threadId) !== usage)
+                return;
+            this.refreshCostPresentation();
+        }
+        catch (error) {
+            usage.rolloutCost = undefined;
+            this.logger.warn({ error, threadId }, "Failed to read a Codex subagent rollout for its cost");
+        }
+    }
+    emitSubAgentSubtitle(threadId, usage, subagentCostUsd = 0) {
+        // A provider subtitle replaces the row's agent type, so it leads with it.
+        const callId = this.subAgentCallIdByChildThreadId.get(threadId);
+        const detail = callId ? this.subAgentCallsByCallId.get(callId)?.toolCall.detail : undefined;
+        const subtitle = [
+            detail?.type === "sub_agent" ? (detail.subAgentType ?? "Codex subagent") : undefined,
+            usage.model,
+            formatSubagentTokens(usage.tokens),
+            ...formatSubagentCosts({ ownCostUsd: usage.costUsd, subagentCostUsd }),
+        ]
+            .filter((part) => part !== undefined)
+            .join(" · ");
+        if (!subtitle || subtitle === usage.subtitle)
+            return;
+        usage.subtitle = subtitle;
+        this.emitEvent({
+            type: "provider_subagent",
+            provider: CODEX_PROVIDER,
+            event: { type: "upsert", id: threadId, subtitle },
+        });
+    }
+    subagentCostRollup() {
+        return rollupProviderSubagentCosts([...this.subAgentCallIdByChildThreadId].map(([threadId, callId]) => ({
+            id: threadId,
+            parentSubagentId: this.subAgentCallsByCallId.get(callId)?.parentSubagentId ?? null,
+            ownCostUsd: this.subAgentUsageByThreadId.get(threadId)?.costUsd ?? 0,
+        })));
+    }
+    refreshCostPresentation() {
+        const costs = this.subagentCostRollup();
+        for (const [threadId, usage] of this.subAgentUsageByThreadId) {
+            this.emitSubAgentSubtitle(threadId, usage, costs.byId.get(threadId)?.subagentCostUsd);
+        }
+        if (!this.latestUsage)
+            return;
+        this.latestUsage = withCostEstimate(this.latestUsage, this.costEstimate, costs.totalCostUsd);
+        this.notifySubscribers({
+            type: "usage_updated",
+            provider: CODEX_PROVIDER,
+            usage: this.latestUsage,
+        });
+    }
     async refreshRolloutCost() {
         const threadId = this.currentThreadId;
         const priceList = this.deps.codexPriceList;
@@ -4979,17 +5081,17 @@ export class CodexAppServerAgentSession {
         this.costEstimate = estimate;
         if (!this.latestUsage)
             return;
-        this.latestUsage = withCostEstimate(this.latestUsage, estimate);
+        this.latestUsage = withCostEstimate(this.latestUsage, estimate, this.subagentCostRollup().totalCostUsd);
         this.notifySubscribers({
             type: "usage_updated",
             provider: CODEX_PROVIDER,
             usage: this.latestUsage,
         });
     }
-    async openRolloutCost(threadId) {
-        if (!this.client)
+    async openRolloutCost(threadId, client = this.client) {
+        if (!client)
             return undefined;
-        const response = toObjectRecord(await this.client.request("thread/read", { threadId, includeTurns: false }));
+        const response = toObjectRecord(await client.request("thread/read", { threadId, includeTurns: false }));
         // Thread.path is marked unstable in the app-server schema; without it there is no estimate.
         const rolloutPath = toObjectRecord(response?.thread)?.path;
         return typeof rolloutPath === "string" ? new CodexRolloutCost(rolloutPath) : undefined;

package/node_modules/@getpaseo/server/dist/server/server/agent/turn-diffs/snapshot.d.ts

@@ -3,12 +3,26 @@ export interface WorkingTreeSnapshot {
     repoRoot: string;
     tree: string;
 }
+export type TurnStartSnapshot = WorkingTreeSnapshot & {
+    head?: string;
+    headLogPath: string;
+    headLogSize: number;
+};
 /**
  * Writes the whole working tree (tracked changes plus untracked, non-ignored files up to 1 MiB)
  * as a git tree object. Staging goes through a copy of the index, so the user's index, HEAD and
  * branches are untouched; only git objects are written.
  */
 export declare function snapshotWorkingTree(cwd: string): Promise<WorkingTreeSnapshot | null>;
+/** A working tree snapshot plus where HEAD and its reflog stood, to separate out branch moves. */
+export declare function snapshotTurnStart(cwd: string): Promise<TurnStartSnapshot | null>;
+/**
+ * The tree to diff a turn from. When the turn moved HEAD to another commit, the start snapshot's
+ * uncommitted changes are replayed onto where HEAD landed, so the diff holds the agent's edits and
+ * commits and none of the content the move brought in. Undefined when that can't be worked out
+ * (no reflog, unborn branch, replay conflict); the turn then gets no diff.
+ */
+export declare function resolveTurnFromTree(start: TurnStartSnapshot): Promise<string | undefined>;
 export declare function diffTreeStats(params: {
     repoRoot: string;
     fromTree: string;

package/node_modules/@getpaseo/server/dist/server/server/agent/turn-diffs/snapshot.js

@@ -15,10 +15,14 @@ async function git(args, options) {
 }
 async function resolveRepo(cwd) {
     try {
-        const [repoRoot, indexPath] = (await git(["rev-parse", "--show-toplevel", "--git-path", "index"], { cwd }))
+        const [repoRoot, indexPath, headLogPath] = (await git(["rev-parse", "--show-toplevel", "--git-path", "index", "--git-path", "logs/HEAD"], { cwd }))
             .trim()
             .split("\n");
-        return { repoRoot, indexPath: path.resolve(cwd, indexPath) };
+        return {
+            repoRoot,
+            indexPath: path.resolve(cwd, indexPath),
+            headLogPath: path.resolve(cwd, headLogPath),
+        };
     }
     catch {
         // Not a git repository (or git is missing): turn diffs are git-only.
@@ -43,6 +47,19 @@ export async function snapshotWorkingTree(cwd) {
     const repo = await resolveRepo(cwd);
     if (!repo)
         return null;
+    return { repoRoot: repo.repoRoot, tree: await writeWorkingTree(repo) };
+}
+/** A working tree snapshot plus where HEAD and its reflog stood, to separate out branch moves. */
+export async function snapshotTurnStart(cwd) {
+    const repo = await resolveRepo(cwd);
+    if (!repo)
+        return null;
+    const headLogSize = await fs.stat(repo.headLogPath).then((stat) => stat.size, () => 0);
+    const head = await readHead(repo.repoRoot);
+    const tree = await writeWorkingTree(repo);
+    return { repoRoot: repo.repoRoot, tree, head, headLogPath: repo.headLogPath, headLogSize };
+}
+async function writeWorkingTree(repo) {
     const tempIndex = path.join(os.tmpdir(), `paseo-turn-index-${randomUUID()}`);
     try {
         const stat = await fs.stat(repo.indexPath).catch(() => null);
@@ -61,13 +78,83 @@ export async function snapshotWorkingTree(cwd) {
                 input: untracked.map((file) => `${file}\0`).join(""),
             });
         }
-        const tree = (await git(["write-tree"], { cwd: repo.repoRoot, env })).trim();
-        return { repoRoot: repo.repoRoot, tree };
+        return (await git(["write-tree"], { cwd: repo.repoRoot, env })).trim();
     }
     finally {
         await fs.rm(tempIndex, { force: true });
     }
 }
+async function readHead(repoRoot) {
+    try {
+        return (await git(["rev-parse", "--verify", "-q", "HEAD"], { cwd: repoRoot })).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readFileFrom(filePath, offset) {
+    const handle = await fs.open(filePath, "r").catch(() => null);
+    if (!handle)
+        return undefined;
+    try {
+        const { size } = await handle.stat();
+        if (size < offset)
+            return undefined;
+        const buffer = Buffer.alloc(size - offset);
+        await handle.read(buffer, 0, buffer.length, offset);
+        return buffer.toString("utf8");
+    }
+    finally {
+        await handle.close();
+    }
+}
+const OWN_COMMIT_MESSAGE = /^commit( \((initial|amend)\))?: /;
+/**
+ * The commit HEAD landed on after the turn's last branch move (checkout, reset, pull, merge,
+ * rebase, cherry-pick), read from the reflog lines the turn appended. Undefined when HEAD only
+ * moved by the agent's own commits; null when the reflog can't tell.
+ */
+async function findLastBranchMove(start) {
+    const appended = await readFileFrom(start.headLogPath, start.headLogSize);
+    if (appended === undefined)
+        return null;
+    let landing;
+    for (const line of appended.split("\n")) {
+        // <old> <new> <identity> <time> <tz>\t<message>
+        const [header, message = ""] = line.split("\t", 2);
+        const [oldHead, newHead] = header.split(" ");
+        if (!newHead || oldHead === newHead || OWN_COMMIT_MESSAGE.test(message))
+            continue;
+        landing = newHead;
+    }
+    return landing;
+}
+/**
+ * The tree to diff a turn from. When the turn moved HEAD to another commit, the start snapshot's
+ * uncommitted changes are replayed onto where HEAD landed, so the diff holds the agent's edits and
+ * commits and none of the content the move brought in. Undefined when that can't be worked out
+ * (no reflog, unborn branch, replay conflict); the turn then gets no diff.
+ */
+export async function resolveTurnFromTree(start) {
+    const head = await readHead(start.repoRoot);
+    if (head === start.head)
+        return start.tree;
+    if (!head || !start.head)
+        return undefined;
+    const landing = await findLastBranchMove(start);
+    if (landing === null)
+        return undefined;
+    if (landing === undefined || landing === start.head)
+        return start.tree;
+    try {
+        const output = await git(["merge-tree", "--write-tree", `--merge-base=${start.head}`, landing, start.tree], { cwd: start.repoRoot });
+        return output.split("\n")[0];
+    }
+    catch {
+        // Exit code 1: the start's uncommitted changes conflict with where HEAD landed.
+        return undefined;
+    }
+}
 export async function diffTreeStats(params) {
     if (params.fromTree === params.toTree)
         return [];

package/node_modules/@getpaseo/server/dist/server/server/agent/turn-diffs/store.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from "pino";
 import { type AgentTurnDiffTarget, type TurnDiffSummary } from "../../messages.js";
-import { type WorkingTreeSnapshot } from "./snapshot.js";
+import { type TurnStartSnapshot } from "./snapshot.js";
 export interface TurnDiffRange {
     repoRoot: string;
     fromTree: string;
@@ -8,7 +8,7 @@ export interface TurnDiffRange {
 }
 export interface RecordTurnInput {
     agentId: string;
-    start: WorkingTreeSnapshot;
+    start: TurnStartSnapshot;
     turnId: string;
     userMessageIds: string[];
 }
@@ -21,7 +21,7 @@ export declare class TurnDiffStore {
     private readonly logger;
     private readonly queues;
     constructor(dir: string, logger: Logger);
-    captureStart(cwd: string): Promise<WorkingTreeSnapshot | null>;
+    captureStart(cwd: string): Promise<TurnStartSnapshot | null>;
     recordTurn(input: RecordTurnInput): Promise<void>;
     list(agentId: string): Promise<TurnDiffSummary[]>;
     resolveRange(agentId: string, target: AgentTurnDiffTarget): Promise<TurnDiffRange | null>;

package/node_modules/@getpaseo/server/dist/server/server/agent/turn-diffs/store.js

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { withTimeout } from "../../../utils/promise-timeout.js";
 import { writeJsonFileAtomic } from "../../atomic-file.js";
 import { TurnDiffFileStatSchema, } from "../../messages.js";
-import { diffTreeStats, snapshotWorkingTree, syncTreeRefs, } from "./snapshot.js";
+import { diffTreeStats, resolveTurnFromTree, snapshotTurnStart, snapshotWorkingTree, syncTreeRefs, } from "./snapshot.js";
 // The prompt waits for the start snapshot; past this, the turn goes without a diff.
 const START_SNAPSHOT_TIMEOUT_MS = 2000;
 const MAX_STORED_TURNS = 200;
@@ -17,15 +17,18 @@ const StoredTurnSchema = TreeRangeSchema.extend({
 });
 const TurnDiffRecordSchema = z.object({
     repoRoot: z.string(),
-    // First snapshot of the chat; "Chat Session" diffs from here. Never trimmed.
-    sessionFromTree: z.string(),
-    // Most recent finished turn, kept even when it changed nothing.
-    lastTurn: TreeRangeSchema,
+    // Most recent finished turn, kept even when it changed nothing. Absent when the turn moved HEAD
+    // in a way its diff couldn't be separated from.
+    lastTurn: TreeRangeSchema.optional(),
     // Turns that changed files, oldest first.
     turns: z.array(StoredTurnSchema),
 });
 function referencedTrees(record) {
-    const trees = new Set([record.sessionFromTree, record.lastTurn.fromTree, record.lastTurn.toTree]);
+    const trees = new Set();
+    if (record.lastTurn) {
+        trees.add(record.lastTurn.fromTree);
+        trees.add(record.lastTurn.toTree);
+    }
     for (const turn of record.turns) {
         trees.add(turn.fromTree);
         trees.add(turn.toTree);
@@ -53,7 +56,7 @@ export class TurnDiffStore {
     async captureStart(cwd) {
         try {
             return await withTimeout({
-                promise: snapshotWorkingTree(cwd),
+                promise: snapshotTurnStart(cwd),
                 timeoutMs: START_SNAPSHOT_TIMEOUT_MS,
                 label: "Turn start snapshot",
             });
@@ -77,9 +80,11 @@ export class TurnDiffStore {
         const { repoRoot } = record;
         switch (target.kind) {
             case "last_turn":
-                return { repoRoot, ...record.lastTurn };
+                return record.lastTurn ? { repoRoot, ...record.lastTurn } : null;
+            // COMPAT(turnDiffSession): added in v0.11.0-beta.3, remove after 2027-01-04. Older clients
+            // can still ask for the removed Chat Session diff; it is always unavailable.
             case "session":
-                return { repoRoot, fromTree: record.sessionFromTree, toTree: record.lastTurn.toTree };
+                return null;
             case "turn": {
                 const turn = record.turns.find((candidate) => candidate.turnId === target.turnId);
                 return turn ? { repoRoot, fromTree: turn.fromTree, toTree: turn.toTree } : null;
@@ -99,26 +104,27 @@ export class TurnDiffStore {
         const end = await snapshotWorkingTree(start.repoRoot);
         if (!end)
             return;
-        const files = await diffTreeStats({
-            repoRoot: start.repoRoot,
-            fromTree: start.tree,
-            toTree: end.tree,
-        });
+        const fromTree = await resolveTurnFromTree(start);
+        if (!fromTree) {
+            this.logger.info({ agentId, turnId }, "Turn moved HEAD in a way its diff can't separate");
+        }
+        const files = fromTree
+            ? await diffTreeStats({ repoRoot: start.repoRoot, fromTree, toTree: end.tree })
+            : [];
         const previous = await this.read(agentId);
         const isSameRepo = previous?.repoRoot === start.repoRoot;
         const record = {
             repoRoot: start.repoRoot,
-            sessionFromTree: isSameRepo ? previous.sessionFromTree : start.tree,
-            lastTurn: { fromTree: start.tree, toTree: end.tree },
+            lastTurn: fromTree ? { fromTree, toTree: end.tree } : undefined,
             turns: isSameRepo ? previous.turns : [],
         };
-        if (files.length > 0) {
+        if (fromTree && files.length > 0) {
             const completedAt = new Date().toISOString();
             const turn = {
                 turnId,
                 userMessageIds,
                 completedAt,
-                fromTree: start.tree,
+                fromTree,
                 toTree: end.tree,
                 files,
             };

package/node_modules/@getpaseo/server/dist/server/web-ui/_expo/static/js/web/{desktop-attachment-bridge-930503b4f858c84de293b25a88bddcd5.js → desktop-attachment-bridge-6eaa3854bb0e0bf2260c50ed5acac196.js}

@@ -1 +1 @@
-__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentBridge=function(){const l=(0,s.createDesktopPreviewUrlResolver)({reader:(0,s.createDesktopFileReader)(),objectUrls:(0,s.createBrowserObjectUrlMinter)()});return{copyFile:t.copyDesktopAttachmentFile,writeBase64:t.writeDesktopAttachmentBase64,writeBytes:t.writeDesktopAttachmentBytes,deleteFile:t.deleteDesktopAttachmentFile,garbageCollect:t.garbageCollectDesktopAttachmentFiles,readFileBase64:s.readDesktopFileBase64,resolvePreviewUrl:t=>l.resolve(t),releasePreviewUrl:t=>l.release(t)}};var t=r(d[0]),s=r(d[1])},5137,[4428,4429]);
+__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentBridge=function(){const l=(0,s.createDesktopPreviewUrlResolver)({reader:(0,s.createDesktopFileReader)(),objectUrls:(0,s.createBrowserObjectUrlMinter)()});return{copyFile:t.copyDesktopAttachmentFile,writeBase64:t.writeDesktopAttachmentBase64,writeBytes:t.writeDesktopAttachmentBytes,deleteFile:t.deleteDesktopAttachmentFile,garbageCollect:t.garbageCollectDesktopAttachmentFiles,readFileBase64:s.readDesktopFileBase64,resolvePreviewUrl:t=>l.resolve(t),releasePreviewUrl:t=>l.release(t)}};var t=r(d[0]),s=r(d[1])},5138,[4429,4430]);

package/node_modules/@getpaseo/server/dist/server/web-ui/_expo/static/js/web/desktop-attachment-bridge-6eaa3854bb0e0bf2260c50ed5acac196.js.br

@@ -0,0 +1,4 @@
+� ���sZ+\
n��Y��K
+
+,��l!�`���:۫|D�Z���
+;�qa���L�[��d��:M�8\��,�*�w�N��AQkH
�ɓP������߰8��@���.e3u��U�`���;E���;Ҙ_AL�i��|�v��vgQq�os��të�E�b�>@�B��s�l�(Q²,� ��[�7(��bdt�o���\-����ں^�D��
Gi�MX+�$���T��h��;Ҝ!@����mTJEVkjF����D*-�N�N���

package/node_modules/@getpaseo/server/dist/server/web-ui/_expo/static/js/web/{desktop-attachment-store-46b63a296048f752e9cace2869e65020.js → desktop-attachment-store-f093e6af17b9293a6d18bd73214b3172.js}

@@ -1 +1 @@
-__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentStore=function(n){return{storageType:"desktop-file",async save(s){const o=s.id??(0,t.generateAttachmentId)(),l=s.fileName??null;if("file_uri"===s.source.kind)return await c(n,{id:o,uri:s.source.uri,mimeType:s.mimeType,fileName:l});if("data_url"===s.source.kind){const c=(0,t.parseDataUrl)(s.source.dataUrl),p=(0,t.normalizeMimeType)(s.mimeType??c.mimeType);return await y(n,{id:o,base64:c.base64,mimeType:p,fileName:l})}if("bytes"===s.source.kind){const c=(0,t.normalizeMimeType)(s.mimeType);return await p(n,{id:o,bytes:s.source.bytes,mimeType:c,fileName:l})}const f=(0,t.normalizeMimeType)(s.mimeType??s.source.blob.type),u=await(0,t.blobToBase64)(s.source.blob);return await y(n,{id:o,base64:u,mimeType:f,fileName:l})},encodeBase64:async({attachment:t})=>(f(t),await n.readFileBase64(t.storageKey)),resolvePreviewUrl:async({attachment:t})=>(f(t),await n.resolvePreviewUrl(t)),async releasePreviewUrl({attachment:t,url:s}){f(t),await n.releasePreviewUrl({url:s})},async delete({attachment:t}){f(t),await n.deleteFile({path:t.storageKey})},async garbageCollect({referencedIds:t}){await n.garbageCollect({referencedIds:Array.from(t)})}}};var t=r(d[0]);const n={"image/png":".png","image/jpeg":".jpg","image/jpg":".jpg","image/gif":".gif","image/webp":".webp","image/avif":".avif","image/heic":".heic","image/heif":".heif","image/tiff":".tiff","image/bmp":".bmp","image/svg+xml":".svg"};function s(t){const n=t.replace(/\\/g,"/").split("/"),s=n[n.length-1];return s&&s.length>0?s:null}function o(s){const o=(0,t.getFileExtensionFromName)(s.fileName);if(o)return o;const l=(0,t.getFileExtensionFromName)(s.sourcePath);return l||(n[s.mimeType]??".img")}function l(t){return{id:t.id,mimeType:t.mimeType,storageType:"desktop-file",storageKey:t.storagePath,fileName:t.fileName??null,byteSize:t.byteSize,createdAt:Date.now()}}async function c(n,c){const y=(0,t.fileUriToPath)(c.uri),p=c.fileName??s(y),f=(0,t.normalizeMimeType)(c.mimeType),u=o({fileName:p,sourcePath:y,mimeType:f}),T=await n.copyFile({attachmentId:c.id,sourcePath:y,extension:u});return l({id:c.id,mimeType:f,storagePath:T.path,byteSize:T.byteSize,fileName:p})}async function y(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBase64({attachmentId:n.id,base64:n.base64,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}async function p(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBytes({attachmentId:n.id,bytes:n.bytes,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}function f(t){if("desktop-file"!==t.storageType)throw new Error(`Unsupported desktop attachment storage type '${t.storageType}'.`)}},5136,[4247]);
+__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentStore=function(n){return{storageType:"desktop-file",async save(s){const o=s.id??(0,t.generateAttachmentId)(),l=s.fileName??null;if("file_uri"===s.source.kind)return await c(n,{id:o,uri:s.source.uri,mimeType:s.mimeType,fileName:l});if("data_url"===s.source.kind){const c=(0,t.parseDataUrl)(s.source.dataUrl),p=(0,t.normalizeMimeType)(s.mimeType??c.mimeType);return await y(n,{id:o,base64:c.base64,mimeType:p,fileName:l})}if("bytes"===s.source.kind){const c=(0,t.normalizeMimeType)(s.mimeType);return await p(n,{id:o,bytes:s.source.bytes,mimeType:c,fileName:l})}const f=(0,t.normalizeMimeType)(s.mimeType??s.source.blob.type),u=await(0,t.blobToBase64)(s.source.blob);return await y(n,{id:o,base64:u,mimeType:f,fileName:l})},encodeBase64:async({attachment:t})=>(f(t),await n.readFileBase64(t.storageKey)),resolvePreviewUrl:async({attachment:t})=>(f(t),await n.resolvePreviewUrl(t)),async releasePreviewUrl({attachment:t,url:s}){f(t),await n.releasePreviewUrl({url:s})},async delete({attachment:t}){f(t),await n.deleteFile({path:t.storageKey})},async garbageCollect({referencedIds:t}){await n.garbageCollect({referencedIds:Array.from(t)})}}};var t=r(d[0]);const n={"image/png":".png","image/jpeg":".jpg","image/jpg":".jpg","image/gif":".gif","image/webp":".webp","image/avif":".avif","image/heic":".heic","image/heif":".heif","image/tiff":".tiff","image/bmp":".bmp","image/svg+xml":".svg"};function s(t){const n=t.replace(/\\/g,"/").split("/"),s=n[n.length-1];return s&&s.length>0?s:null}function o(s){const o=(0,t.getFileExtensionFromName)(s.fileName);if(o)return o;const l=(0,t.getFileExtensionFromName)(s.sourcePath);return l||(n[s.mimeType]??".img")}function l(t){return{id:t.id,mimeType:t.mimeType,storageType:"desktop-file",storageKey:t.storagePath,fileName:t.fileName??null,byteSize:t.byteSize,createdAt:Date.now()}}async function c(n,c){const y=(0,t.fileUriToPath)(c.uri),p=c.fileName??s(y),f=(0,t.normalizeMimeType)(c.mimeType),u=o({fileName:p,sourcePath:y,mimeType:f}),T=await n.copyFile({attachmentId:c.id,sourcePath:y,extension:u});return l({id:c.id,mimeType:f,storagePath:T.path,byteSize:T.byteSize,fileName:p})}async function y(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBase64({attachmentId:n.id,base64:n.base64,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}async function p(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBytes({attachmentId:n.id,bytes:n.bytes,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}function f(t){if("desktop-file"!==t.storageType)throw new Error(`Unsupported desktop attachment storage type '${t.storageType}'.`)}},5137,[4247]);