@fungi.computer/oyster 0.0.1 → 0.1.0

package/dist/mcp-owner.js

@@ -1,11 +1,21 @@
 import { DurableObject } from "cloudflare:workers";
 import { nanoid } from "@fungi.computer/cairn";
-import { createMcp, createMcpCatalog, } from "@fungi.computer/mycelium/mcp";
 import { createCodemodeSandbox } from "@fungi.computer/mycelium/workers";
-import { parseJSONRPCMessage, serializeMessage, } from "@modelcontextprotocol/server";
 import * as Schema from "effect/Schema";
 import { oysterMcpCatalogLoad } from "./mcp.js";
 import { tenantIdSchema, tenantScope } from "./tenant.js";
+/**
+ * The MCP protocol SDK builds hundreds of schemas when it loads. Only the first
+ * MCP request needs them, so the owner loads it then and the Worker's startup
+ * (which every request and every deploy pays) never does.
+ */
+const loadMcpProtocol = async () => {
+    const [mycelium, sdk] = await Promise.all([
+        import("@fungi.computer/mycelium/mcp"),
+        import("@modelcontextprotocol/server"),
+    ]);
+    return { mycelium, sdk };
+};
 const pinSchema = Schema.Struct({
     tenant_id: tenantIdSchema,
     origin: Schema.String,
@@ -37,7 +47,7 @@ export class OysterMcpOwner extends DurableObject {
             ctx.storage.sql.exec("DELETE FROM oyster_mcp_sessions");
         });
     }
-    #eventStore(catalogId) {
+    #eventStore(catalogId, { sdk }) {
         const sql = this.ctx.storage.sql;
         const find = (eventId) => {
             const row = sql
@@ -50,7 +60,7 @@ export class OysterMcpOwner extends DurableObject {
         return {
             storeEvent: (streamId, message) => {
                 const id = nanoid();
-                sql.exec("INSERT INTO oyster_mcp_events (catalog_id, event_id, stream_id, message) VALUES (?,?,?,?)", catalogId, id, streamId, serializeMessage(message));
+                sql.exec("INSERT INTO oyster_mcp_events (catalog_id, event_id, stream_id, message) VALUES (?,?,?,?)", catalogId, id, streamId, sdk.serializeMessage(message));
                 return Promise.resolve(id);
             },
             getStreamIdForEventId: (id) => Promise.resolve(find(id)?.stream_id),
@@ -63,7 +73,7 @@ export class OysterMcpOwner extends DurableObject {
                     .toArray();
                 for (const raw of rows) {
                     const row = Schema.decodeUnknownSync(eventSchema)(raw);
-                    await send(row.event_id, parseJSONRPCMessage(JSON.parse(row.message)));
+                    await send(row.event_id, sdk.parseJSONRPCMessage(JSON.parse(row.message)));
                 }
                 return after.stream_id;
             },
@@ -87,10 +97,12 @@ export class OysterMcpOwner extends DurableObject {
         else {
             sql.exec("INSERT INTO oyster_mcp_tenant (id, tenant_id, origin) VALUES (1,?,?)", scope.tenantId, scope.origin);
         }
+        // Loaded before the check so the session map is still created exactly once.
+        const protocol = await loadMcpProtocol();
         if (this.#mcp === undefined) {
             const host = this.#createHost(this.env, scope);
             const persistence = {
-                eventStore: (id) => this.#eventStore(id),
+                eventStore: (id) => this.#eventStore(id, protocol),
                 initialized: (id, session) => {
                     sql.exec("INSERT INTO oyster_mcp_sessions (protocol_id, catalog_id, principal) VALUES (?,?,?)", id, session.id, JSON.stringify(session.principal));
                     return Promise.resolve();
@@ -103,9 +115,9 @@ export class OysterMcpOwner extends DurableObject {
                     return Promise.resolve();
                 },
             };
-            this.#mcp = createMcp({
+            this.#mcp = protocol.mycelium.createMcp({
                 persistence,
-                catalog: createMcpCatalog({
+                catalog: protocol.mycelium.createMcpCatalog({
                     load: oysterMcpCatalogLoad(host),
                     sandbox: createCodemodeSandbox(this.env.LOADER),
                 }),

package/dist/pack.d.ts

@@ -62,9 +62,12 @@ export declare function installRelease(input: Readonly<{
     key: string;
     installationId?: string;
 }>): Promise<Response>;
-/** Project one exact first-party commit's editable source and seed it into
- * an Oyster's own template, so `APPS.fork` can later fork it. The operator
- * owner key authenticates; no provider credential ever leaves this call. */
+/** Project one exact first-party commit's editable source, `git push` it to
+ * an Oyster's own template for that App, and claim the pushed head, so
+ * `APPS.fork` and Computer builds can later read it. The operator owner key
+ * authenticates both; it reaches Git only through its config environment and
+ * no provider credential ever leaves the Oyster. Answers the claim response:
+ * `{ kind: "recorded" | "existing", receipt }` on success. */
 export declare function publishSource(input: Readonly<{
     appId: string;
     entry: string;

package/dist/pack.js

@@ -5,8 +5,9 @@ import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import { releaseSchema } from "@fungi.computer/puffball/effect";
 import { parseArtifactRef, parseReleaseId, parseSha256Digest, parseSourceRevision, } from "@fungi.computer/puffball";
-import { commitPreparedCandidate, createAppCandidatePreparer, createArtifactsSourceCapture, createFirstPartyAppSourceDistribution, createLocalArtifactWriter, createLocalBuildExecutor, createLocalCommitSourceCapture, } from "./build.js";
-import { templateWriteInputSchema } from "./source/template-write.js";
+import { commitPreparedCandidate, createAppCandidatePreparer, createArtifactsSourceCapture, createFirstPartyAppSourceDistribution, createLocalArtifactWriter, createLocalBuildExecutor, createLocalCommitSourceCapture, normalizeAppPublisherRecipe, } from "./build.js";
+import { templateSeedClaimSchema, } from "./source/template-seed.js";
+import { pushTemplateSource } from "./source/template-push.js";
 import { sha256 } from "./release.js";
 async function filesUnder(directory) {
     const entries = await readdir(directory, {
@@ -103,9 +104,12 @@ export async function installRelease(input) {
         }),
     });
 }
-/** Project one exact first-party commit's editable source and seed it into
- * an Oyster's own template, so `APPS.fork` can later fork it. The operator
- * owner key authenticates; no provider credential ever leaves this call. */
+/** Project one exact first-party commit's editable source, `git push` it to
+ * an Oyster's own template for that App, and claim the pushed head, so
+ * `APPS.fork` and Computer builds can later read it. The operator owner key
+ * authenticates both; it reaches Git only through its config environment and
+ * no provider credential ever leaves the Oyster. Answers the claim response:
+ * `{ kind: "recorded" | "existing", receipt }` on success. */
 export async function publishSource(input) {
     const revision = parseSourceRevision(input.sourceRevision);
     const distribution = await Effect.runPromise(Effect.scoped(Effect.gen(function* () {
@@ -116,19 +120,32 @@ export async function publishSource(input) {
             source,
         });
     })));
-    const body = Schema.encodeUnknownSync(templateWriteInputSchema)({
+    const app = encodeURIComponent(input.appId);
+    const authorization = `Bearer ${input.key}`;
+    const { seedRevision } = await pushTemplateSource({
         appId: input.appId,
         sourceRevision: revision,
-        sourceTreeDigest: distribution.sourceTreeDigest,
-        recipe: input.recipe,
         files: distribution.files,
+        remote: new URL(`/api/apps/${app}/source.git`, input.url).href,
+        headers: { Authorization: authorization },
     });
-    return fetch(new URL(`/api/apps/${encodeURIComponent(input.appId)}/source`, input.url), {
+    const claim = {
+        appId: distribution.appId,
+        sourceRevision: revision,
+        sourceTreeDigest: distribution.sourceTreeDigest,
+        seedRevision,
+        // The template pins the same captured recipe its forks build with.
+        recipe: normalizeAppPublisherRecipe({
+            appId: input.appId,
+            recipe: input.recipe,
+        }).recipe,
+    };
+    return fetch(new URL(`/api/apps/${app}/source`, input.url), {
         method: "PUT",
         headers: {
-            Authorization: `Bearer ${input.key}`,
+            Authorization: authorization,
             "Content-Type": "application/json",
         },
-        body: JSON.stringify(body),
+        body: JSON.stringify(Schema.encodeUnknownSync(templateSeedClaimSchema)(claim)),
     });
 }

package/dist/page/gill-observation.d.ts

@@ -0,0 +1,4 @@
+/** One desktop observation notifies the shell until it is closed. */
+export declare function observeDesktopGill(onChanged: () => Promise<void>, openSource: () => (Pick<EventTarget, "addEventListener"> & {
+    close(): void;
+}) | null, focus: Pick<EventTarget, "addEventListener" | "removeEventListener">): () => void;

package/dist/page/gill-observation.js

@@ -0,0 +1,31 @@
+/** One desktop observation notifies the shell until it is closed. */
+export function observeDesktopGill(onChanged, openSource, focus) {
+    let closed = false;
+    const notify = () => {
+        if (!closed)
+            void onChanged().catch((cause) => {
+                console.error("Desktop Gill observation failed", cause);
+            });
+    };
+    let source = null;
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        source?.close();
+        focus.removeEventListener("focus", notify);
+    };
+    try {
+        source = openSource();
+        if (source !== null)
+            for (const event of ["ready", "rows", "reset", "changed"])
+                source.addEventListener(event, notify);
+        else
+            focus.addEventListener("focus", notify);
+        return close;
+    }
+    catch (error) {
+        close();
+        throw error;
+    }
+}

package/dist/page/window-launch.d.ts

@@ -0,0 +1,18 @@
+import type { AppOpenRequest } from "@fungi.computer/agar";
+/**
+ * A window's current launch target: the open request and Computer its child
+ * App should see. `reconfigure` moves this forward as the window is handed a
+ * new file; a later restore (`setVisibility`) must read the latest target
+ * here, never the window's first open request.
+ */
+export type WindowLaunchTarget = Readonly<{
+    openRequest: AppOpenRequest | null;
+    computerId: string | null;
+}>;
+export type WindowLaunchTracker = Readonly<{
+    current: () => WindowLaunchTarget;
+    advance: (next: WindowLaunchTarget) => void;
+}>;
+/** One window's launch history: starts at its first open, moves forward on
+ * every `reconfigure`, and never resets on its own. */
+export declare function createWindowLaunchTracker(initial: WindowLaunchTarget): WindowLaunchTracker;

package/dist/page/window-launch.js

@@ -0,0 +1,11 @@
+/** One window's launch history: starts at its first open, moves forward on
+ * every `reconfigure`, and never resets on its own. */
+export function createWindowLaunchTracker(initial) {
+    let current = initial;
+    return {
+        current: () => current,
+        advance: (next) => {
+            current = next;
+        },
+    };
+}