@makerstufferupper/flypi 0.1.3 → 0.1.5

package/src/server/protocol.ts

@@ -332,7 +332,17 @@ export const PackageRow = Type.Object({
 	scope: Type.Union([Type.Literal("user"), Type.Literal("project")]),
 	installed: Type.Boolean(),
 	path: Type.String(),
+	/** The version the installed code's own `package.json` says. A source that names a version is pinned,
+	 *  and this is what tells the reader which version that is (docs/pi-upgrades.md). */
+	version: Type.Optional(Type.String()),
 	update: Type.Optional(Type.Boolean()),
+	/** The npm package an `npm:` source names, version stripped. Absent for a git URL or a path, and its
+	 *  presence next to a source that is not `npm:<name>` is what reads as pinned. */
+	name: Type.Optional(Type.String()),
+	/** Published releases, oldest first, from the same daily stamp — what "install this version" offers. */
+	versions: Type.Optional(Type.Array(Type.String())),
+	/** The newest published release newer than what is installed. */
+	available: Type.Optional(Type.String()),
 });
 
 export const PackagesSnapshot = Type.Object({
@@ -367,6 +377,60 @@ export const SavePackagesCommand = Type.Object({
 	requestId: Type.Optional(RequestId),
 });
 
+/**
+ * Which pi answers, what is on disk to move to, and what the daemon's daily registry answer said (Phase 8.4,
+ * docs/pi-upgrades.md). `latest`/`next` are absent until the daemon has asked — the request itself reaches no
+ * network, the same rule `packages` follows.
+ */
+export const PiVersions = Type.Object({
+	/** The version this process loaded. */
+	running: Type.String(),
+	pinned: Type.Boolean(),
+	/** What the tree flypi was installed with holds, when that is not what is running. */
+	bundled: Type.Optional(Type.String()),
+	/** The pi versions with a tree on disk — what "switch back" can offer. */
+	trees: Type.Array(Type.String()),
+	next: Type.Optional(Type.String()),
+	latest: Type.Optional(Type.String()),
+	checkedAt: Type.Optional(Type.String()),
+});
+
+export type PiVersions = Static<typeof PiVersions>;
+
+/** Ask what pi this flypi runs and what it could move to. Reaches no network. */
+export const PiVersionsCommand = Type.Object({
+	type: Type.Literal("piVersions"),
+	requestId: Type.Optional(RequestId),
+});
+
+/**
+ * Ask the registry for pi now instead of on the daemon's daily rhythm. The reply is a fresh `piVersions`, so
+ * the page needs no new frame; nothing moves by itself either way.
+ */
+export const PiCheckCommand = Type.Object({
+	type: Type.Literal("piCheck"),
+	requestId: Type.Optional(RequestId),
+});
+
+/**
+ * Move to a published pi version. The daemon flips the pointer and hands the restart to the CLI — the same
+ * path `installUpdate` takes — and the ack goes out before the restart closes this socket. The switch is
+ * provisional: if the new process does not answer reporting that version, the pointer goes back on its own
+ * (docs/risks.md risk 13), so the page comes back and says which version it is on.
+ */
+export const UsePiCommand = Type.Object({
+	type: Type.Literal("usePi"),
+	version: Type.String({ minLength: 1 }),
+	requestId: Type.Optional(RequestId),
+});
+
+/** The same call with an older version — only offered for the trees still on disk. */
+export const RollbackPiCommand = Type.Object({
+	type: Type.Literal("rollbackPi"),
+	version: Type.String({ minLength: 1 }),
+	requestId: Type.Optional(RequestId),
+});
+
 /** What kind of secret a row claims to be — the same list the vault's schema allows (src/secrets/crypto.ts). */
 export const SecretKind = Type.Union([
 	Type.Literal("password"),
@@ -567,6 +631,10 @@ export const ClientCommandSchema = Type.Union([
 	McpRedirectCommand,
 	PackagesCommand,
 	SavePackagesCommand,
+	PiVersionsCommand,
+	PiCheckCommand,
+	UsePiCommand,
+	RollbackPiCommand,
 	SecretsCommand,
 	SaveSecretsCommand,
 	RevealSecretCommand,
@@ -579,10 +647,20 @@ export type ClientCommand = Static<typeof ClientCommandSchema>;
 /** A pi session event, passed through verbatim. Only the discriminator is checked here. */
 export const SessionEventFrameBody = Type.Object({ type: Type.String() }, { additionalProperties: true });
 
+/** Which pi answers (docs/pi-upgrades.md Phase 8.1): the version loaded, and what chose it. */
+export const PiInfoFrame = Type.Object({
+	version: Type.String(),
+	pinned: Type.Boolean(),
+	/** What the tree flypi was installed with holds, when that is not what is running. */
+	bundled: Type.Optional(Type.String()),
+});
+
 export const HelloFrame = Type.Object({
 	type: Type.Literal("hello"),
 	protocolVersion: Type.Integer(),
 	serverVersion: Type.String(),
+	/** Optional so an older server still parses; every flypi server from here on sends it. */
+	pi: Type.Optional(PiInfoFrame),
 });
 
 export const EventFrame = Type.Object({
@@ -817,6 +895,7 @@ export const ResultFrame = Type.Object({
 	mcpStatus: Type.Optional(McpStatusSnapshot),
 	config: Type.Optional(ConfigSnapshot),
 	packages: Type.Optional(PackagesSnapshot),
+	pi: Type.Optional(PiVersions),
 	scheduler: Type.Optional(SchedulerSnapshot),
 	secrets: Type.Optional(SecretsSnapshot),
 	revealed: Type.Optional(RevealedSecret),

package/src/server/session-registry.ts

@@ -126,11 +126,33 @@ export class SessionRegistry {
 		);
 	}
 
-	/** Rebind a conversation to an existing session file. The conversationId — what the client holds — does not change. */
+	/**
+	 * Open an existing session for a client: the conversation already answering it when there is one, and
+	 * otherwise this conversation moved onto it — or a new one, if this conversation is mid-turn.
+	 */
 	async switchSession(conversationId: string, sessionPath: string): Promise<Conversation> {
 		const conversation = this.get(conversationId);
 		const target = this.sessionFileIn(sessionPath);
+		// Already answering it: opening the file a second time would put a second writer on it, so the
+		// conversation the page is already on stays where it is. An idle one is reopened as asked — that is
+		// how a client reloads a session's history from disk.
+		if (conversation.session.sessionFile === target && !conversation.session.isIdle) return conversation;
+		// A session another conversation is already answering **is** that conversation, not a copy of it. Opening
+		// the file a second time would put a second writer on it and freeze the transcript at the moment of the
+		// switch, so the answer on its way would never reach the page that just asked for that session.
+		const live = [...this.conversations.values()].find((other) => other.id !== conversationId && other.session.sessionFile === target);
+		if (live) return live;
+		// Rebinding disposes the session this conversation is answering in, and a turn still running would be cut
+		// short: its answer would reach neither the page nor the session file. So a session with no conversation
+		// of its own is opened as one, and this conversation is left alone to finish (it stays in the map, and
+		// switching back to it returns it from the lookup above, log and all).
+		if (!conversation.session.isIdle) return this.bind(SessionManager.open(target, this.paths.sessionsDir));
 		this.teardown(conversation);
+		// The conversation lives on with a new session, so it is not disposed any more. Without this the
+		// exactly-once guard below stays set and the *new* session is never unsubscribed or disposed — it
+		// keeps streaming into this conversation's log (and its listeners) after the page moved on, keeps
+		// the conversation unevictable, and writes back any session file it is deleted out from under.
+		conversation.disposed = false;
 		conversation.session = await this.createSession({
 			sessionManager: SessionManager.open(target, this.paths.sessionsDir),
 			conversationId,
@@ -171,7 +193,9 @@ export class SessionRegistry {
 
 	get(conversationId: string): Conversation {
 		const conversation = this.conversations.get(conversationId);
-		if (!conversation) throw new Error(`unknown conversation ${conversationId}`);
+		// The code is what a page acts on: it holds a conversation id across reconnects, and after a restart
+		// every command it sends names a conversation this process never had (ui/lib/app-state.svelte.ts).
+		if (!conversation) throw Object.assign(new Error(`unknown conversation ${conversationId}`), { code: "unknownConversation" });
 		return conversation;
 	}