@vibesdotdev/code-sessions 0.0.0-stage → 1.0.0-rc.1

package/dist/svelte/actions.js

@@ -0,0 +1,280 @@
+import { CapabilityError, CaughtFailureSchema } from '@vibesdotdev/kernel';
+import { JsonValueSchema } from '@vibesdotdev/kernel/schemas/json';
+import * as z from 'zod/v4';
+import { readUntrusted } from "./outcome.js";
+const DEFAULT_CREATE_FAILURE_MESSAGE = 'Could not start the session. Please try again.';
+const DEFAULT_DELETE_FAILURE_MESSAGE = 'Could not delete session. Try again.';
+const DEFAULT_PUBLISH_FAILURE_MESSAGE = 'Could not publish this branch. Try again.';
+const DEFAULT_MESSAGE_FIELDS = [
+    'createMessage',
+    'deleteMessage',
+    'publishMessage',
+    'message',
+    'error'
+];
+const NonBlankStringSchema = z.string().refine((value) => value.trim().length > 0);
+/**
+ * The serialized action result, each field read independently: a malformed
+ * `status` never hides a readable `data` message, and a hostile value is read
+ * once inside {@link readUntrusted}.
+ */
+const ActionResultSchema = z.object({
+    type: z.string().optional().catch(undefined),
+    status: z.number().int().optional().catch(undefined),
+    data: z.unknown().optional(),
+    location: NonBlankStringSchema.optional().catch(undefined),
+    error: z.unknown().optional()
+});
+const MessageRecordSchema = z.record(z.string(), z.unknown());
+const MessageCarrierSchema = z.union([
+    NonBlankStringSchema,
+    z.object({ message: NonBlankStringSchema }).transform((carrier) => carrier.message)
+]);
+const SessionIdCarrierSchema = z.object({ sessionId: NonBlankStringSchema });
+function messageFromData(result, fields = DEFAULT_MESSAGE_FIELDS) {
+    const direct = NonBlankStringSchema.safeParse(result.data);
+    if (direct.success)
+        return direct.data;
+    const record = readUntrusted(MessageRecordSchema, result.data);
+    if (record.outcome !== 'parsed')
+        return null;
+    for (const field of fields) {
+        const value = NonBlankStringSchema.safeParse(record.data[field]);
+        if (value.success)
+            return value.data;
+    }
+    return null;
+}
+function messageFromError(result) {
+    const carrier = readUntrusted(MessageCarrierSchema, result.error);
+    return carrier.outcome === 'parsed' ? carrier.data : null;
+}
+function parseActionOutcome(result, responseStatus, options) {
+    const read = readUntrusted(ActionResultSchema, result);
+    if (read.outcome !== 'parsed') {
+        return {
+            ok: false,
+            status: responseStatus,
+            message: options.fallbackMessage
+        };
+    }
+    const actionResult = read.data;
+    const status = actionResult.status ?? responseStatus;
+    switch (actionResult.type) {
+        case 'success': {
+            const outcome = {
+                ok: true,
+                status
+            };
+            if (actionResult.data !== undefined) {
+                outcome.data = actionResult.data;
+            }
+            const carrier = readUntrusted(SessionIdCarrierSchema, actionResult.data);
+            if (carrier.outcome === 'parsed') {
+                outcome.sessionId = carrier.data.sessionId;
+            }
+            return outcome;
+        }
+        case 'redirect': {
+            const outcome = {
+                ok: true,
+                status
+            };
+            if (actionResult.data !== undefined) {
+                outcome.data = actionResult.data;
+            }
+            if (actionResult.location !== undefined) {
+                outcome.redirectLocation = actionResult.location;
+            }
+            return outcome;
+        }
+        case 'failure':
+            return {
+                ok: false,
+                status,
+                data: actionResult.data,
+                resultType: 'failure',
+                message: messageFromData(actionResult, options.messageFields) ?? options.fallbackMessage
+            };
+        case 'error':
+            return {
+                ok: false,
+                status,
+                data: actionResult.data,
+                resultType: 'error',
+                message: messageFromError(actionResult) ??
+                    messageFromData(actionResult, options.messageFields) ??
+                    options.fallbackMessage
+            };
+        default:
+            return {
+                ok: false,
+                status,
+                data: actionResult.data,
+                resultType: actionResult.type,
+                message: messageFromData(actionResult, options.messageFields) ?? options.fallbackMessage
+            };
+    }
+}
+async function submitSvelteKitAction(fetcher, deserialize, formData, options) {
+    const response = await fetcher(options.action, {
+        method: 'POST',
+        headers: { accept: 'application/json' },
+        body: formData
+    });
+    const text = await response.text();
+    let result;
+    try {
+        result = deserialize(text);
+    }
+    catch (error) {
+        // Not an action result (a proxy's HTML page, a server crash page): the
+        // person sees the surface's own copy and the status, never the raw body.
+        return {
+            ok: false,
+            status: response.status,
+            message: options.fallbackMessage,
+            failure: new CapabilityError('The action response could not be read.', 'INTERNAL', {
+                reason: 'action-response-unreadable',
+                details: { status: response.status },
+                cause: CaughtFailureSchema.parse(error)
+            })
+        };
+    }
+    return parseActionOutcome(result, response.status, options);
+}
+export function createCodeSessionActionFormData(input) {
+    const body = new FormData();
+    body.set('hostTarget', JSON.stringify(input.hostTarget));
+    if ('repositoryId' in input && input.repositoryId) {
+        body.set('repositoryId', input.repositoryId);
+    }
+    if ('checkoutRef' in input && input.checkoutRef) {
+        body.set('checkoutRef', input.checkoutRef);
+    }
+    if ('ephemeral' in input && input.ephemeral) {
+        body.set('ephemeral', 'true');
+    }
+    // The seed is what lets a finished session say which work item it came from.
+    // It was absent here while the dialog and the create input both carried it, so
+    // the object looked correct at every unit boundary and the REAL HTTP request
+    // still forgot the work item — a green that stopped being true at the wire.
+    if (input.seed) {
+        body.set('seed', JSON.stringify(input.seed));
+    }
+    return body;
+}
+/**
+ * Read the seed back off an action FormData. The parser lives beside the
+ * serializer deliberately: the two are one contract, and a server route
+ * hand-rolling `JSON.parse(data.get('seed'))` is how the shapes drift apart.
+ *
+ * Absent seed → `undefined`; sessions without an originating record are normal.
+ * PRESENT BUT MALFORMED → throws. A caller that sent a seed meant to attach one,
+ * and silently dropping it would mint an untraceable session while reporting
+ * success — the same failure class as forgetting to serialize it.
+ */
+export function parseCodeSessionSeedFormValue(value) {
+    if (value === null || value === undefined || value === '')
+        return undefined;
+    if (value instanceof File)
+        throw invalidSeed('seed must be a JSON string, received a file upload');
+    let parsed;
+    try {
+        parsed = SeedJsonSchema.parse(JSON.parse(value));
+    }
+    catch (error) {
+        throw invalidSeed('seed is not valid JSON', CaughtFailureSchema.parse(error));
+    }
+    const seed = readUntrusted(SeedFieldsSchema, parsed);
+    if (seed.outcome !== 'parsed')
+        throw invalidSeed('seed must be an object');
+    // `source` and `title` are the two the platform threads into the sandbox as
+    // VIBES_SEED_*; a seed missing either is not traceable and is not worth attaching.
+    if (seed.data.source === undefined)
+        throw invalidSeed('seed.source is required');
+    if (seed.data.title === undefined)
+        throw invalidSeed('seed.title is required');
+    const out = { source: seed.data.source, title: seed.data.title };
+    if (seed.data.ref !== undefined)
+        out.ref = seed.data.ref;
+    if (seed.data.body !== undefined)
+        out.body = seed.data.body;
+    return out;
+}
+/** JSON text as a value; any JSON parses. */
+const SeedJsonSchema = JsonValueSchema;
+/** Each seed field read on its own: a non-string optional field is dropped, never fatal. */
+const NonEmptyStringSchema = z.string().min(1);
+const SeedFieldsSchema = z.object({
+    source: NonEmptyStringSchema.optional().catch(undefined),
+    title: NonEmptyStringSchema.optional().catch(undefined),
+    ref: NonEmptyStringSchema.optional().catch(undefined),
+    body: NonEmptyStringSchema.optional().catch(undefined)
+});
+/** A malformed seed: `INVALID_INPUT` / `seed-invalid`. */
+function invalidSeed(message, cause) {
+    return new CapabilityError(message, 'INVALID_INPUT', { reason: 'seed-invalid', cause });
+}
+export function deleteCodeSessionActionFormData(sessionId) {
+    const body = new FormData();
+    body.set('sessionId', sessionId);
+    return body;
+}
+export async function submitCodeSessionCreateAction(fetcher, deserialize, input, options = {}) {
+    return submitSvelteKitAction(fetcher, deserialize, createCodeSessionActionFormData(input), {
+        action: options.action ?? '?/create',
+        fallbackMessage: options.fallbackMessage ?? DEFAULT_CREATE_FAILURE_MESSAGE,
+        messageFields: options.messageFields ?? DEFAULT_MESSAGE_FIELDS
+    });
+}
+/**
+ * Form body for publishing a session's branch.
+ *
+ * `branch` is optional and OMITTED when blank rather than sent empty: the server
+ * treats an absent branch as "use whatever the session is actually on", which is
+ * the right default and the only thing a caller can honestly say without reading
+ * the workspace. Sending `branch=''` would look like a deliberate choice of a
+ * branch named nothing.
+ */
+export function publishCodeSessionActionFormData(branch) {
+    const body = new FormData();
+    const trimmed = branch?.trim();
+    if (trimmed)
+        body.set('branch', trimmed);
+    return body;
+}
+/**
+ * Publish the session's branch through the surface's own `?/publish` action.
+ *
+ * A refused push — protected branch, non-fast-forward, a lapsed entitlement — is
+ * an ordinary outcome with a message worth reading, not an exception. It comes
+ * back as `{ok: false, message}` like every other action here, so the surface
+ * shows it instead of replacing the page the person was watching.
+ */
+export async function submitCodeSessionPublishAction(fetcher, deserialize, branch, options = {}) {
+    return submitSvelteKitAction(fetcher, deserialize, publishCodeSessionActionFormData(branch), {
+        action: options.action ?? '?/publish',
+        fallbackMessage: options.fallbackMessage ?? DEFAULT_PUBLISH_FAILURE_MESSAGE,
+        messageFields: options.messageFields ?? DEFAULT_MESSAGE_FIELDS
+    });
+}
+const DEFAULT_CREATE_PR_FAILURE_MESSAGE = 'Could not open a pull request. Try again.';
+/**
+ * Open a forge PR from the published session branch via `?/createPullRequest`.
+ * Title/body/head are re-planned on the platform — not invented by the form.
+ */
+export async function submitCodeSessionCreatePullRequestAction(fetcher, deserialize, options = {}) {
+    return submitSvelteKitAction(fetcher, deserialize, new FormData(), {
+        action: options.action ?? '?/createPullRequest',
+        fallbackMessage: options.fallbackMessage ?? DEFAULT_CREATE_PR_FAILURE_MESSAGE,
+        messageFields: options.messageFields ?? ['prMessage', 'message', 'error']
+    });
+}
+export async function submitCodeSessionDeleteAction(fetcher, deserialize, sessionId, options = {}) {
+    return submitSvelteKitAction(fetcher, deserialize, deleteCodeSessionActionFormData(sessionId), {
+        action: options.action ?? '?/delete',
+        fallbackMessage: options.fallbackMessage ?? DEFAULT_DELETE_FAILURE_MESSAGE,
+        messageFields: options.messageFields ?? DEFAULT_MESSAGE_FIELDS
+    });
+}

package/dist/svelte/clock.svelte.d.ts

@@ -0,0 +1,6 @@
+export interface SharedNow {
+    readonly value: number;
+}
+/** Subscribe after client activation. SSR runs no effect and starts no timer. */
+export declare function sharedNow(): SharedNow;
+//# sourceMappingURL=clock.svelte.d.ts.map

package/dist/svelte/clock.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.svelte.d.ts","sourceRoot":"","sources":["../../src/svelte/clock.svelte.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,SAAS;IAAG,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CAAE;AAEtD,iFAAiF;AACjF,wBAAgB,SAAS,IAAI,SAAS,CA2BrC"}

package/dist/svelte/clock.svelte.js

@@ -0,0 +1,33 @@
+import { getVibesClient, tryGetVibesClient } from '@vibesdotdev/kernel/client';
+import { getRuntimeSvelteContext } from '@vibesdotdev/surface-sveltekit/svelte';
+import { getLogger } from '@vibesdotdev/logging';
+import { attempt } from "./outcome.js";
+/** Subscribe after client activation. SSR runs no effect and starts no timer. */
+export function sharedNow() {
+    const context = getRuntimeSvelteContext();
+    const cell = $state({ now: Date.now() });
+    $effect(() => {
+        const runtime = context.runtime;
+        if (!runtime)
+            return;
+        const lifecycle = runtime.lifecycle;
+        let cancelled = false;
+        let release;
+        void attempt(async () => {
+            const clock = await getVibesClient('code-sessions.clock', runtime);
+            await clock.ensureLoaded();
+            return clock;
+        }).then(activated => {
+            if (cancelled || lifecycle.signal.aborted)
+                return;
+            if (!activated.ok) {
+                getLogger('code-sessions:clock', runtime).warn('Shared clock activation failed.', { error: activated.failure });
+                return;
+            }
+            const clock = tryGetVibesClient('code-sessions.clock', runtime);
+            release = clock?.subscribe(now => { cell.now = now; });
+        });
+        return () => { cancelled = true; release?.(); };
+    });
+    return { get value() { return cell.now; } };
+}