@parall/cli 1.55.3 → 1.55.5

package/dist/lib/client.d.ts

@@ -28,6 +28,13 @@ export type RuntimeContext = {
     dispatchSourceId?: string;
     /** Trigger thread root (parel invocation context) — the by-source send's default thread. */
     threadRootId?: string;
+    /**
+     * Conversation generation of this execution (parel v2 invocation context,
+     * PRLL_GENERATION). Rides every dispatch_source send; the server rejects a
+     * mutation whose generation predates a New Session barrier. Absent on v1
+     * and lane-bound turns.
+     */
+    generation?: number;
 };
 /**
  * Read per-dispatch context from ENV + sideband files.
@@ -49,25 +56,36 @@ export declare function resolveRuntimeContext(): RuntimeContext;
 export declare function resolveSourceDispatchBinding(ctx: RuntimeContext, chatId: string, threadRootId: string | undefined): {
     source_type: string;
     source_id: string;
+    generation?: number;
 } | null;
 /** Typed dispatch binding for a task write, derived from the turn context. */
 export type TypedDispatchBinding = {
-    lane: string;
+    /** Claimed typed lane (v1 consumers). Absent on the converged transport,
+     *  where no lane exists and the write binds by dispatch_event_id under the
+     *  generation fence instead. */
+    lane?: string;
     dispatchEventId: string;
+    /** Conversation generation (converged transport, PRLL_GENERATION). */
+    generation?: number;
     /** Set for the first (resolving) update of this dispatch. */
     effectKey?: string;
     markCommitted: () => void;
 };
 /**
- * Resolve the typed-lane binding for `parall task update <taskId>`: the
- * current turn must be a typed dispatch (lane target `dsp:<id>`) about this
- * exact task. The first update carries the canonical
+ * Resolve the typed dispatch binding for `parall task update <taskId>`: the
+ * current turn must be a typed dispatch about this exact task.
+ *
+ * Lane-bound (v1): the first update carries the canonical
  * `task_update:<dispatch_event_id>` effect key (resolves the WorkItem in the
- * same transaction); later updates go keyless (lane-checked only). The
- * committed flag lives in a CLI-owned sidecar keyed by the typed lane; when
+ * same transaction); later updates go keyless (lane-checked only), with the
+ * committed flag in a CLI-owned sidecar keyed by the typed lane. When
  * PRLL_CONTEXT_DIR is absent the sidecar can't exist, so no effect key is
  * ever attached (a blind key would make a *different* second update replay
  * the first one's result instead of applying).
+ *
+ * Converged (no lane): the caller appends a payload hash to the base key —
+ * content addressing gives every distinct update its own idempotent key, so
+ * no sidecar state is needed at all.
  */
 export declare function resolveTypedDispatchBinding(taskId: string): TypedDispatchBinding | null;
 /** Per-lane dispatch context (PRLL_CONTEXT_DIR contract), keyed by send target. */

package/dist/lib/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/lib/client.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,6DAA6D;AAC7D,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,oGAAoG;IACpG,OAAO,EAAE,OAAO,CAAC;IACjB,8EAA8E;IAC9E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sFAAsF;IACtF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,4FAA4F;IAC5F,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,IAAI,cAAc,CAyDtD;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GAAG,SAAS,GAC/B;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAKnD;AAED,8EAA8E;AAC9E,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,CAAC;IACxB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,IAAI,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI,CAwCvF;AAED,mFAAmF;AACnF,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;CAAG;AAE9C;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,YAAY,CAAC,EAAE,MAAM,GACpB,mBAAmB,GAAG,IAAI,CA+E5B;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAYzE;AAED,wBAAgB,kBAAkB,IAAI,mBAAmB,CA8BxD"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/lib/client.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,6DAA6D;AAC7D,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,oGAAoG;IACpG,OAAO,EAAE,OAAO,CAAC;IACjB,8EAA8E;IAC9E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sFAAsF;IACtF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,4FAA4F;IAC5F,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,IAAI,cAAc,CAkEtD;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GAAG,SAAS,GAC/B;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAWxE;AAED,8EAA8E;AAC9E,MAAM,MAAM,oBAAoB,GAAG;IACjC;;oCAEgC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,MAAM,CAAC;IACxB,sEAAsE;IACtE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,IAAI,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI,CA8DvF;AAED,mFAAmF;AACnF,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;CAAG;AAE9C;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,YAAY,CAAC,EAAE,MAAM,GACpB,mBAAmB,GAAG,IAAI,CA+E5B;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAYzE;AAED,wBAAgB,kBAAkB,IAAI,mBAAmB,CA8BxD"}

package/dist/lib/client.js

@@ -18,10 +18,15 @@ export function resolveRuntimeContext() {
     const dispatchSourceType = process.env.PRLL_DISPATCH_SOURCE_TYPE?.trim() || undefined;
     const dispatchSourceId = process.env.PRLL_DISPATCH_SOURCE_ID?.trim() || undefined;
     const threadRootId = process.env.PRLL_THREAD_ROOT_ID?.trim() || undefined;
-    let dispatchEventId;
-    let lane;
-    let laneTargetUri;
-    let taskId;
+    const generationRaw = process.env.PRLL_GENERATION?.trim();
+    const generation = generationRaw && /^\d+$/.test(generationRaw) ? Number(generationRaw) : undefined;
+    // Parel v2 surfaces the lane context as plain env (there is no context
+    // file inside a parel sandbox); the CC/Codex context file below still wins
+    // per-field when both exist.
+    let dispatchEventId = process.env.PRLL_DISPATCH_EVENT_ID?.trim() || undefined;
+    let lane = process.env.PRLL_DISPATCH_LANE?.trim() || undefined;
+    let laneTargetUri = process.env.PRLL_LANE_TARGET_URI?.trim() || undefined;
+    let taskId = process.env.PRLL_TASK_ID?.trim() || undefined;
     if (process.env.PRLL_CONTEXT_FILE) {
         try {
             const raw = fs.readFileSync(process.env.PRLL_CONTEXT_FILE, 'utf-8').trim();
@@ -33,10 +38,12 @@ export function resolveRuntimeContext() {
                 stepId ??= ctx.step_id || undefined;
                 if (ctx.no_reply === true)
                     noReply = true;
-                dispatchEventId = ctx.dispatch_event_id || undefined;
-                lane = ctx.lane || undefined;
-                laneTargetUri = ctx.target_uri || undefined;
-                taskId = ctx.task_id || undefined;
+                // The file wins per-field over the parel env fallbacks above, but an
+                // absent field must not erase them.
+                dispatchEventId = ctx.dispatch_event_id || dispatchEventId;
+                lane = ctx.lane || lane;
+                laneTargetUri = ctx.target_uri || laneTargetUri;
+                taskId = ctx.task_id || taskId;
             }
         }
         catch {
@@ -66,6 +73,7 @@ export function resolveRuntimeContext() {
         dispatchSourceType,
         dispatchSourceId,
         threadRootId,
+        generation,
     };
 }
 /**
@@ -83,36 +91,67 @@ export function resolveSourceDispatchBinding(ctx, chatId, threadRootId) {
         return null;
     if ((threadRootId ?? '') !== (ctx.threadRootId ?? ''))
         return null;
-    return { source_type: ctx.dispatchSourceType, source_id: ctx.dispatchSourceId };
+    return {
+        source_type: ctx.dispatchSourceType,
+        source_id: ctx.dispatchSourceId,
+        // v2 executions carry their conversation generation; the server fences
+        // stale-generation replies inside the commit transaction.
+        ...(ctx.generation !== undefined ? { generation: ctx.generation } : {}),
+    };
 }
 /**
- * Resolve the typed-lane binding for `parall task update <taskId>`: the
- * current turn must be a typed dispatch (lane target `dsp:<id>`) about this
- * exact task. The first update carries the canonical
+ * Resolve the typed dispatch binding for `parall task update <taskId>`: the
+ * current turn must be a typed dispatch about this exact task.
+ *
+ * Lane-bound (v1): the first update carries the canonical
  * `task_update:<dispatch_event_id>` effect key (resolves the WorkItem in the
- * same transaction); later updates go keyless (lane-checked only). The
- * committed flag lives in a CLI-owned sidecar keyed by the typed lane; when
+ * same transaction); later updates go keyless (lane-checked only), with the
+ * committed flag in a CLI-owned sidecar keyed by the typed lane. When
  * PRLL_CONTEXT_DIR is absent the sidecar can't exist, so no effect key is
  * ever attached (a blind key would make a *different* second update replay
  * the first one's result instead of applying).
+ *
+ * Converged (no lane): the caller appends a payload hash to the base key —
+ * content addressing gives every distinct update its own idempotent key, so
+ * no sidecar state is needed at all.
  */
 export function resolveTypedDispatchBinding(taskId) {
     const ctx = resolveRuntimeContext();
-    if (!ctx.lane || !ctx.dispatchEventId)
-        return null;
-    if (!ctx.laneTargetUri?.startsWith('dsp:'))
+    if (!ctx.dispatchEventId)
         return null;
     if (!ctx.taskId || ctx.taskId !== taskId)
         return null;
-    const binding = {
-        lane: ctx.lane,
-        dispatchEventId: ctx.dispatchEventId,
-        markCommitted: () => { },
-    };
+    let binding;
+    let sidecarKey;
+    if (!ctx.lane) {
+        // Converged transport: no lane exists — the write binds by
+        // dispatch_event_id under the server's generation fence. A context with
+        // no generation must NOT produce a binding: an unfenced by-id write
+        // would bypass the New Session barrier (the server rejects it anyway —
+        // failing closed here keeps the task update itself working as a plain
+        // write). Content-addressed keys replace the reply-slot sidecar on this
+        // path: the caller appends a payload hash to the base key, so a
+        // same-payload retry replays its own key idempotently while a different
+        // second update mints a new key and lands as its own Effect.
+        if (ctx.generation === undefined)
+            return null;
+        return {
+            dispatchEventId: ctx.dispatchEventId,
+            generation: ctx.generation,
+            effectKey: `task_update:${ctx.dispatchEventId}`,
+            markCommitted: () => { },
+        };
+    }
+    // Lane-bound (v1 consumers): the write rides the claimed typed lane and
+    // the reply-slot sidecar arbitrates the single resolving key.
+    if (!ctx.laneTargetUri?.startsWith('dsp:'))
+        return null;
+    binding = { lane: ctx.lane, dispatchEventId: ctx.dispatchEventId, markCommitted: () => { } };
+    sidecarKey = ctx.laneTargetUri;
     const contextDir = process.env.PRLL_CONTEXT_DIR?.trim();
     if (!contextDir)
         return binding;
-    const sidecarPath = laneReplyStateFilePath(contextDir, ctx.laneTargetUri);
+    const sidecarPath = laneReplyStateFilePath(contextDir, sidecarKey);
     let committed = false;
     try {
         const sidecar = JSON.parse(fs.readFileSync(sidecarPath, 'utf-8'));
@@ -122,19 +161,22 @@ export function resolveTypedDispatchBinding(taskId) {
     catch {
         // No sidecar yet — resolving update not committed.
     }
-    if (!committed) {
-        const dispatchEventId = ctx.dispatchEventId;
-        binding.effectKey = `task_update:${dispatchEventId}`;
-        binding.markCommitted = () => {
-            try {
-                fs.writeFileSync(sidecarPath, JSON.stringify({ dispatch_event_id: dispatchEventId, reply_committed: true }), 'utf-8');
-            }
-            catch {
-                // Best-effort — a lost sidecar means the next update retries the key
-                // and the server's effect ledger replies idempotently.
-            }
-        };
+    if (committed) {
+        // Resolving update already landed: later updates go keyless.
+        delete binding.effectKey;
+        return binding;
     }
+    const dispatchEventId = ctx.dispatchEventId;
+    binding.effectKey = `task_update:${dispatchEventId}`;
+    binding.markCommitted = () => {
+        try {
+            fs.writeFileSync(sidecarPath, JSON.stringify({ dispatch_event_id: dispatchEventId, reply_committed: true }), 'utf-8');
+        }
+        catch {
+            // Best-effort — a lost sidecar means the next update retries the key
+            // and the server's effect ledger replies idempotently.
+        }
+    };
     return binding;
 }
 /**

package/dist/lib/output.d.ts

@@ -21,5 +21,5 @@ export declare function ensurePrllScheme(idOrUri: string): string;
  * than receiving a malformed value.
  */
 export declare function parsePositiveInt(raw: string | undefined): number | undefined;
-export declare function printError(err: unknown): never;
+export declare function printError(err: unknown, attemptedPayload?: Record<string, unknown>): never;
 //# sourceMappingURL=output.d.ts.map

package/dist/lib/output.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../src/lib/output.ts"],"names":[],"mappings":"AAEA,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAE7C;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAY,GAAG,IAAI,CAEvE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAW5E;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,KAAK,CAwC9C"}
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../src/lib/output.ts"],"names":[],"mappings":"AAEA,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAE7C;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAY,GAAG,IAAI,CAEvE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAW5E;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,EAAE,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,CA8C1F"}

package/dist/lib/output.js

@@ -43,7 +43,7 @@ export function parsePositiveInt(raw) {
     const n = Number(t);
     return Number.isInteger(n) && n > 0 ? n : undefined;
 }
-export function printError(err) {
+export function printError(err, attemptedPayload) {
     if (err instanceof ApiError) {
         // Faithful, parseable line: the server's real message + machine anchors.
         console.error(JSON.stringify({
@@ -70,7 +70,13 @@ export function printError(err) {
                     ? 'This action can be approved.'
                     : 'This action may be approvable.';
                 const chat = err.resourceUri?.startsWith('prll://cht_') ? err.resourceUri : '<chat_id>';
-                console.error(`${lead} Request approval:\n  parall approvals request --action ${err.action} --resource ${err.resourceUri ?? '<resource>'} --chat ${chat} --title "..." --reason "..."`);
+                // When the failing command knows exactly what it tried to write, the
+                // proposal command is prefilled with that payload — the deny → propose
+                // loop then needs no re-assembly by the caller.
+                const payloadArg = attemptedPayload
+                    ? ` --payload '${JSON.stringify(attemptedPayload).replaceAll("'", `'\\''`)}'`
+                    : '';
+                console.error(`${lead} Request approval:\n  parall approvals request --action ${err.action} --resource ${err.resourceUri ?? '<resource>'}${payloadArg} --chat ${chat} --title "..." --reason "..."`);
             }
         }
     }

package/dist/lib/update-check.d.ts

@@ -0,0 +1,29 @@
+import { spawn } from 'node:child_process';
+export declare const UPDATE_CHECK_TIMEOUT_MS = 1500;
+type UpdateNotifierOptions = {
+    now?: () => number;
+    cachePath?: string;
+    spawnWorker?: (cachePath: string) => void;
+    writeHint?: (hint: string) => void;
+    disabled?: boolean;
+};
+type RefreshOptions = {
+    now?: () => number;
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+    registryUrl?: string;
+};
+export type UpdateNotifier = {
+    afterSuccessfulCommand: () => void;
+};
+export declare function isNewerRelease(currentVersion: string, latestVersion: string): boolean;
+/**
+ * Acquire the cache's cross-process lock. The token check prevents a stale
+ * owner from deleting a replacement lock when it eventually resumes.
+ */
+export declare function acquireUpdateStateLock(cachePath: string, now?: () => number): (() => void) | null;
+export declare function spawnUpdateCheckWorker(cachePath: string, spawnImpl?: typeof spawn): void;
+export declare function createUpdateNotifier(currentVersion: string, options?: UpdateNotifierOptions): UpdateNotifier;
+export declare function refreshUpdateCache(cachePath: string, options?: RefreshOptions): Promise<void>;
+export {};
+//# sourceMappingURL=update-check.d.ts.map

package/dist/lib/update-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-check.d.ts","sourceRoot":"","sources":["../../src/lib/update-check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAW3C,eAAO,MAAM,uBAAuB,OAAQ,CAAC;AAS7C,KAAK,qBAAqB,GAAG;IAC3B,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,KAAK,cAAc,GAAG;IACpB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,sBAAsB,EAAE,MAAM,IAAI,CAAC;CACpC,CAAC;AAQF,wBAAgB,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAUrF;AA4CD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,GAAG,GAAE,MAAM,MAAiB,GAC3B,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAkErB;AAgBD,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,GAAE,OAAO,KAAa,GAAG,IAAI,CAW/F;AAWD,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,MAAM,EACtB,OAAO,GAAE,qBAA0B,GAClC,cAAc,CAyDhB;AAED,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC,CA+Bf"}

package/dist/lib/update-check.js

@@ -0,0 +1,269 @@
+import { spawn } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const REGISTRY_URL = 'https://registry.npmjs.org/@parall%2Fcli/latest';
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const RETRY_INTERVAL_MS = 60 * 60 * 1000;
+const LOCK_STALE_MS = 30_000;
+export const UPDATE_CHECK_TIMEOUT_MS = 1_500;
+function releaseParts(version) {
+    const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(version);
+    if (!match)
+        return null;
+    return [BigInt(match[1]), BigInt(match[2]), BigInt(match[3])];
+}
+export function isNewerRelease(currentVersion, latestVersion) {
+    const current = releaseParts(currentVersion);
+    const latest = releaseParts(latestVersion);
+    if (!current || !latest)
+        return false;
+    for (let i = 0; i < current.length; i++) {
+        if (latest[i] > current[i])
+            return true;
+        if (latest[i] < current[i])
+            return false;
+    }
+    return false;
+}
+function defaultCachePath() {
+    const envRoot = process.env.XDG_CACHE_HOME?.trim();
+    const cacheRoot = envRoot ||
+        (process.platform === 'win32' && process.env.LOCALAPPDATA?.trim()) ||
+        path.join(os.homedir(), '.cache');
+    return path.join(cacheRoot, 'parall', 'update-check.json');
+}
+function readState(cachePath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+        const state = {};
+        if (typeof parsed.latest_version === 'string')
+            state.latest_version = parsed.latest_version;
+        if (typeof parsed.last_success_at === 'number')
+            state.last_success_at = parsed.last_success_at;
+        if (typeof parsed.last_attempt_at === 'number')
+            state.last_attempt_at = parsed.last_attempt_at;
+        if (typeof parsed.last_notified_at === 'number') {
+            state.last_notified_at = parsed.last_notified_at;
+        }
+        return state;
+    }
+    catch {
+        return {};
+    }
+}
+function writeState(cachePath, state) {
+    const tempPath = `${cachePath}.${process.pid}.tmp`;
+    try {
+        fs.mkdirSync(path.dirname(cachePath), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(tempPath, `${JSON.stringify(state)}\n`, { encoding: 'utf8', mode: 0o600 });
+        fs.renameSync(tempPath, cachePath);
+        return true;
+    }
+    catch {
+        try {
+            fs.unlinkSync(tempPath);
+        }
+        catch {
+            // Best-effort cleanup only.
+        }
+        return false;
+    }
+}
+/**
+ * Acquire the cache's cross-process lock. The token check prevents a stale
+ * owner from deleting a replacement lock when it eventually resumes.
+ */
+export function acquireUpdateStateLock(cachePath, now = Date.now) {
+    const lockPath = `${cachePath}.lock`;
+    const withTokenGate = (token, action) => {
+        const tokenHash = createHash('sha256').update(token).digest('hex');
+        const gatePath = `${lockPath}.reclaim-${tokenHash}`;
+        const gateToken = `${process.pid}:${randomUUID()}`;
+        try {
+            fs.writeFileSync(gatePath, gateToken, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+        }
+        catch {
+            return undefined;
+        }
+        try {
+            return action();
+        }
+        finally {
+            try {
+                if (fs.readFileSync(gatePath, 'utf8') === gateToken)
+                    fs.unlinkSync(gatePath);
+            }
+            catch {
+                // A lost/replaced gate is already released from this owner's perspective.
+            }
+        }
+    };
+    const tryAcquire = () => {
+        const token = `${process.pid}:${randomUUID()}`;
+        try {
+            fs.mkdirSync(path.dirname(cachePath), { recursive: true, mode: 0o700 });
+            fs.writeFileSync(lockPath, token, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+        }
+        catch {
+            return null;
+        }
+        return () => {
+            withTokenGate(token, () => {
+                try {
+                    if (fs.readFileSync(lockPath, 'utf8') === token)
+                        fs.unlinkSync(lockPath);
+                }
+                catch {
+                    // A lost/replaced lock is already released from this owner's perspective.
+                }
+            });
+        };
+    };
+    const release = tryAcquire();
+    if (release)
+        return release;
+    let staleToken;
+    try {
+        staleToken = fs.readFileSync(lockPath, 'utf8');
+        if (now() - fs.statSync(lockPath).mtimeMs < LOCK_STALE_MS)
+            return null;
+    }
+    catch (err) {
+        return err.code === 'ENOENT' ? tryAcquire() : null;
+    }
+    return (withTokenGate(staleToken, () => {
+        try {
+            if (fs.readFileSync(lockPath, 'utf8') !== staleToken)
+                return null;
+            if (now() - fs.statSync(lockPath).mtimeMs < LOCK_STALE_MS)
+                return null;
+            fs.unlinkSync(lockPath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                return null;
+        }
+        return tryAcquire();
+    }) ?? null);
+}
+function withUpdateStateLock(cachePath, now, update) {
+    const release = acquireUpdateStateLock(cachePath, now);
+    if (!release)
+        return undefined;
+    try {
+        return update();
+    }
+    finally {
+        release();
+    }
+}
+export function spawnUpdateCheckWorker(cachePath, spawnImpl = spawn) {
+    const workerPath = fileURLToPath(new URL('../update-check-worker.js', import.meta.url));
+    const child = spawnImpl(process.execPath, [workerPath, cachePath], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    child.on('error', () => {
+        // A missing/broken Node binary must not turn a completed CLI command into a failure.
+    });
+    child.unref();
+}
+function updateChecksDisabled() {
+    const ci = process.env.CI?.trim().toLowerCase();
+    return (process.env.PRLL_DISABLE_UPDATE_CHECK === '1' ||
+        process.env.NO_UPDATE_NOTIFIER === '1' ||
+        Boolean(ci && ci !== '0' && ci !== 'false'));
+}
+export function createUpdateNotifier(currentVersion, options = {}) {
+    const now = options.now ?? Date.now;
+    const cachePath = options.cachePath ?? defaultCachePath();
+    const spawnWorker = options.spawnWorker ?? spawnUpdateCheckWorker;
+    const writeHint = options.writeHint ?? ((hint) => process.stderr.write(hint));
+    const disabled = options.disabled ?? updateChecksDisabled();
+    return {
+        afterSuccessfulCommand: () => {
+            if (disabled || !releaseParts(currentVersion))
+                return;
+            const timestamp = now();
+            const decision = withUpdateStateLock(cachePath, now, () => {
+                const state = readState(cachePath);
+                let hint;
+                let changed = false;
+                if (state.latest_version &&
+                    isNewerRelease(currentVersion, state.latest_version) &&
+                    timestamp - (state.last_notified_at ?? 0) >= CHECK_INTERVAL_MS) {
+                    hint =
+                        `Update available: parall ${currentVersion} → ${state.latest_version}. ` +
+                            'Upgrade @parall/cli@latest with your package manager.\n';
+                    state.last_notified_at = timestamp;
+                    changed = true;
+                }
+                const successfulCheckIsFresh = timestamp - (state.last_success_at ?? 0) < CHECK_INTERVAL_MS;
+                const recentAttempt = timestamp - (state.last_attempt_at ?? 0) < RETRY_INTERVAL_MS;
+                const shouldSpawnWorker = !successfulCheckIsFresh && !recentAttempt;
+                if (shouldSpawnWorker) {
+                    state.last_attempt_at = timestamp;
+                    changed = true;
+                }
+                if (changed && !writeState(cachePath, state))
+                    return undefined;
+                return { hint, shouldSpawnWorker };
+            });
+            if (!decision)
+                return;
+            if (decision.hint) {
+                try {
+                    writeHint(decision.hint);
+                }
+                catch {
+                    // A closed output stream must not change the command's exit status.
+                }
+            }
+            if (!decision.shouldSpawnWorker)
+                return;
+            try {
+                spawnWorker(cachePath);
+            }
+            catch {
+                // Update checks never affect the command that triggered them.
+            }
+        },
+    };
+}
+export async function refreshUpdateCache(cachePath, options = {}) {
+    const fetchImpl = options.fetch ?? fetch;
+    const timeoutMs = options.timeoutMs ?? UPDATE_CHECK_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetchImpl(options.registryUrl ?? REGISTRY_URL, {
+            headers: { accept: 'application/json' },
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return;
+        const body = (await response.json());
+        if (typeof body.version !== 'string' || !releaseParts(body.version))
+            return;
+        const latestVersion = body.version;
+        const now = options.now ?? Date.now;
+        withUpdateStateLock(cachePath, now, () => {
+            const state = readState(cachePath);
+            writeState(cachePath, {
+                ...state,
+                latest_version: latestVersion,
+                last_success_at: now(),
+            });
+        });
+    }
+    catch {
+        // Network, timeout, registry, and cache failures are intentionally silent.
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/lib/upload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/lib/upload.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AA6BhD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGtD;AAED,wBAAsB,UAAU,CAC9B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAyBzF"}
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/lib/upload.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AA6BhD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGtD;AAED,wBAAsB,UAAU,CAC9B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAgFzF"}

package/dist/lib/upload.js

@@ -39,16 +39,71 @@ export async function uploadFile(client, orgId, filePath) {
         file_name: fileName,
         file_size: stat.size,
         mime_type: mimeType,
+        multipart_supported: true,
     });
-    const fileBuffer = fs.readFileSync(resolved);
-    const uploadRes = await fetch(presign.upload_url, {
-        method: 'PUT',
-        body: fileBuffer,
-        headers: { 'Content-Type': mimeType },
-    });
-    if (!uploadRes.ok) {
-        throw new Error(`Upload failed: ${uploadRes.status} ${uploadRes.statusText}`);
+    let completionStarted = false;
+    try {
+        let completedParts;
+        if (presign.upload_type === 'multipart') {
+            if (!presign.part_size || !presign.parts?.length) {
+                throw new Error('Server returned an invalid multipart upload response');
+            }
+            const file = await fs.promises.open(resolved, 'r');
+            try {
+                completedParts = [];
+                const orderedParts = [...presign.parts].sort((a, b) => a.part_number - b.part_number);
+                for (const part of orderedParts) {
+                    const position = (part.part_number - 1) * presign.part_size;
+                    const length = Math.min(presign.part_size, stat.size - position);
+                    if (length <= 0) {
+                        throw new Error(`Upload part ${part.part_number} is outside the file bounds`);
+                    }
+                    const buffer = Buffer.allocUnsafe(length);
+                    let bytesRead = 0;
+                    while (bytesRead < length) {
+                        const result = await file.read(buffer, bytesRead, length - bytesRead, position + bytesRead);
+                        if (result.bytesRead === 0)
+                            throw new Error('Unexpected end of file');
+                        bytesRead += result.bytesRead;
+                    }
+                    const uploadRes = await fetch(part.upload_url, {
+                        method: 'PUT',
+                        body: buffer,
+                        headers: { 'Content-Type': mimeType },
+                    });
+                    if (!uploadRes.ok) {
+                        throw new Error(`Upload part ${part.part_number} failed: ${uploadRes.status} ${uploadRes.statusText}`);
+                    }
+                    const etag = uploadRes.headers.get('ETag');
+                    if (!etag)
+                        throw new Error(`Upload part ${part.part_number} returned no ETag`);
+                    completedParts.push({ part_number: part.part_number, etag });
+                }
+            }
+            finally {
+                await file.close();
+            }
+        }
+        else {
+            if (!presign.upload_url)
+                throw new Error('Server did not return an upload URL');
+            const fileBuffer = fs.readFileSync(resolved);
+            const uploadRes = await fetch(presign.upload_url, {
+                method: 'PUT',
+                body: fileBuffer,
+                headers: { 'Content-Type': mimeType },
+            });
+            if (!uploadRes.ok) {
+                throw new Error(`Upload failed: ${uploadRes.status} ${uploadRes.statusText}`);
+            }
+        }
+        completionStarted = true;
+        await client.completeUpload(orgId, presign.attachment_id, completedParts);
+    }
+    catch (error) {
+        if (!completionStarted)
+            await client.abortUpload(orgId, presign.attachment_id).catch(() => { });
+        throw error;
     }
-    await client.completeUpload(orgId, presign.attachment_id);
     return { attachmentId: presign.attachment_id, fileName, fileSize: stat.size, mimeType };
 }