offsite 0.0.95 → 0.0.96

package/apps/server/dist/main.mjs

@@ -22,7 +22,7 @@ import { sumBy } from "es-toolkit";
 import { DatabaseSync } from "node:sqlite";
 import { drizzle } from "drizzle-orm/node-sqlite";
 import { migrate } from "drizzle-orm/node-sqlite/migrator";
-import { integer, real, snakeCase, text } from "drizzle-orm/sqlite-core";
+import { integer, primaryKey, real, snakeCase, text } from "drizzle-orm/sqlite-core";
 import sharp from "sharp";
 import webPush from "web-push";
 import dns from "node:dns";
@@ -1165,10 +1165,7 @@ function record$1(value) {
 	return isRecord(value) ? value : { value };
 }
 // src/storage/config.ts
-const modelSetting = z.strictObject({
-	hidden: z.boolean(),
-	effort: z.string().nullable()
-});
+const modelSetting = z.strictObject({ hidden: z.boolean() });
 const generationModel = z.strictObject({
 	provider: z.enum([
 		"claude",
@@ -1274,7 +1271,7 @@ function configInfo() {
 		defaultClaudeBaseDir: path.join(os.homedir(), ".claude"),
 		homeDir: os.homedir(),
 		scratchAvailable,
-		version: "v0.0.95"
+		version: "v0.0.96"
 	};
 }
 function readConfig() {
@@ -3160,6 +3157,15 @@ const lastUsedModels = snakeCase.table("last_used_models", {
 	model: text().notNull(),
 	usedAt: integer().notNull()
 });
+const lastEfforts = snakeCase.table("last_efforts", {
+	provider: text({ enum: [
+		"claude",
+		"codex",
+		"opencode"
+	] }).notNull(),
+	model: text().notNull(),
+	effort: text()
+}, (table) => [primaryKey({ columns: [table.provider, table.model] })]);
 // src/storage/auth.ts
 const CODE_LIFETIME = 3e5;
 const DEVICE_LIFETIME = 2592e6;
@@ -4897,17 +4903,14 @@ async function capabilities(provider, accountId, cwd) {
 		defaultModel: defaultModels[provider],
 		models: result.models.map((model) => {
 			const deprecated = deprecatedModels[provider].includes(model.value);
-			const setting = settings[model.value] ?? {
-				hidden: deprecated,
-				effort: null
-			};
+			const setting = settings[model.value] ?? { hidden: deprecated };
 			const preferred = defaultEfforts[provider];
 			const effort = preferred === null ? null : model.efforts.includes(preferred) ? preferred : model.efforts.at(-1) ?? null;
 			return {
 				...model,
 				deprecated,
 				hidden: setting.hidden,
-				effort: setting.effort ?? effort
+				effort
 			};
 		})
 	};
@@ -6764,6 +6767,13 @@ function sessionHistory(sessionId, cwd) {
 		case "opencode": return openCodeHistory(sessionId, cwd);
 	}
 }
+function agentHistory(sessionId, cwd, agentId, parent) {
+	switch (providerOf(sessionId)) {
+		case "claude": return agentMessages(sessionId, cwd, agentId, parent);
+		case "codex": return codexAgent(agentId, parent);
+		case "opencode": return openCodeAgent(agentId, parent);
+	}
+}
 function rewind(request) {
 	return locked(request.sessionId, () => rewindNow(request));
 }
@@ -6822,6 +6832,24 @@ async function rewindNow(request) {
 	publish$2(sessionId, await history$1(sessionId, cwd));
 	return result;
 }
+function restart(sessionId) {
+	return locked(sessionId, async () => {
+		const run = runs.get(sessionId);
+		if (run === void 0) return;
+		if (run.provider !== "claude") throw new Error("Only Claude Code threads can be restarted");
+		if (run.running) await run.interrupt();
+		run.stop();
+		await run.closed;
+		new Run({
+			sessionId,
+			cwd: run.cwd,
+			resume: true,
+			resumeAt: null,
+			settings: run.settings
+		});
+		publish$2(sessionId, await history$1(sessionId, run.cwd));
+	});
+}
 async function open$1(client, sessionId, projectId) {
 	client.opening = sessionId;
 	const event = await sessionHistory(sessionId, projectPath(projectId));
@@ -8453,6 +8481,15 @@ const lastUsedSchema = z.discriminatedUnion("provider", [z.strictObject({
 	accountId: z.null(),
 	model: z.string()
 })]);
+const lastEffortSchema = z.strictObject({
+	provider: z.enum([
+		"claude",
+		"codex",
+		"opencode"
+	]),
+	model: z.string(),
+	effort: z.string().nullable()
+});
 function readLastUsed() {
 	return db.select().from(lastUsedModels).all();
 }
@@ -8473,6 +8510,22 @@ function saveLastUsed(value) {
 	});
 	return null;
 }
+function readLastEfforts() {
+	return db.select().from(lastEfforts).all();
+}
+function saveLastEffort(value) {
+	const result = lastEffortSchema.safeParse(value);
+	if (!result.success) throw new Error(z.prettifyError(result.error));
+	db.insert(lastEfforts).values(result.data).onConflictDoUpdate({
+		target: [lastEfforts.provider, lastEfforts.model],
+		set: { effort: result.data.effort }
+	}).run();
+	broadcast({
+		type: "lastEfforts",
+		lastEfforts: readLastEfforts()
+	});
+	return null;
+}
 // ../core/src/app-icons.ts
 const appIcons = [
 	{
@@ -8573,6 +8626,7 @@ const handlers = {
 		return {
 			...configInfo(),
 			lastUsed: readLastUsed(),
+			lastEfforts: readLastEfforts(),
 			hostname: os.hostname(),
 			projects: projects(),
 			sessions: sessions(),
@@ -8584,6 +8638,7 @@ const handlers = {
 	},
 	"config.get": () => configInfo(),
 	"lastUsed.save": (params) => saveLastUsed(params),
+	"lastEffort.save": (params) => saveLastEffort(params),
 	"appIcon.save": (params) => saveAppIcon(params),
 	"config.save": async (params) => {
 		const before = readConfig();
@@ -8645,13 +8700,7 @@ const handlers = {
 	"sessions.earlier": (params) => earlier(params.sessionId, params.before),
 	"sessions.export": (params) => exportSession(params.sessionId, params.projectId),
 	"sessions.image": (params) => image(params.sessionId, params.itemId, params.index),
-	"sessions.agent": (params) => {
-		switch (providerOf(params.sessionId)) {
-			case "claude": return agentMessages(params.sessionId, projectPath(params.projectId), params.agentId, params.parent);
-			case "codex": return codexAgent(params.agentId, params.parent);
-			case "opencode": return openCodeAgent(params.agentId, params.parent);
-		}
-	},
+	"sessions.agent": (params) => agentHistory(params.sessionId, projectPath(params.projectId), params.agentId, params.parent),
 	"sessions.send": async (params, client) => {
 		await send$1(client, params);
 		return null;
@@ -8668,6 +8717,10 @@ const handlers = {
 		await runs.get(params.sessionId)?.interrupt();
 		return null;
 	},
+	"sessions.restart": async (params) => {
+		await restart(params.sessionId);
+		return null;
+	},
 	"sessions.stopTask": async (params) => {
 		await runs.get(params.sessionId)?.stopTask(params.taskId);
 		return null;