spiracha 1.4.0 → 1.5.0

package/apps/ui/dist/server/assets/opencode-db-BM7KjOzc.js

@@ -0,0 +1,397 @@
+import { i as asString, n as asNumber, r as asObject } from "./shared-DyhChtHf.js";
+import { t as splitOpenCodeThinkTaggedText } from "./opencode-think-tags-CAoD-EcZ.js";
+import { stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { Database, constants } from "bun:sqlite";
+import { pathToFileURL } from "node:url";
+//#region ../../src/lib/opencode-exporter-types.ts
+var getDefaultOpenCodeDataDir = (env = process.env, homeDir = os.homedir()) => {
+	return path.join(env.XDG_DATA_HOME || path.join(homeDir, ".local", "share"), "opencode");
+};
+var DEFAULT_OPENCODE_DATA_DIR = getDefaultOpenCodeDataDir();
+var resolveOpenCodeDataDir = () => {
+	const configured = process.env.SPIRACHA_OPENCODE_DATA_DIR?.trim() || process.env.SPIRACHA_OPENCODE_DIR?.trim();
+	return configured ? configured : DEFAULT_OPENCODE_DATA_DIR;
+};
+var resolveOpenCodeDbPath = () => {
+	const configured = process.env.SPIRACHA_OPENCODE_DB?.trim();
+	return configured ? configured : path.join(resolveOpenCodeDataDir(), "opencode.db");
+};
+//#endregion
+//#region ../../src/lib/opencode-db.ts
+var OPENCODE_READONLY_DB_OPEN_FLAGS = constants.SQLITE_OPEN_READONLY | constants.SQLITE_OPEN_URI;
+var MAIN_SESSION_FILTER = "s.parent_id IS NULL";
+var pathExists = async (target) => {
+	return await stat(target).then(() => true).catch(() => false);
+};
+var getOpenCodeReadonlyDbUri = (dbPath) => {
+	const url = pathToFileURL(dbPath);
+	url.searchParams.set("mode", "ro");
+	return url.href;
+};
+var openOpenCodeReadonlyDb = (dbPath) => {
+	return new Database(getOpenCodeReadonlyDbUri(dbPath), OPENCODE_READONLY_DB_OPEN_FLAGS);
+};
+var parseJsonValue = (value) => {
+	if (!value) return null;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+};
+var parseJsonObject = (value) => {
+	return asObject(parseJsonValue(value)) ?? {};
+};
+var cleanLabel = (value) => {
+	const cleaned = value?.replace(/\s+/g, " ").trim();
+	return cleaned ? cleaned : null;
+};
+var getWorkspaceLabel = (name, worktree) => {
+	const named = cleanLabel(name);
+	if (named) return named;
+	if (worktree === "/") return "(global)";
+	return path.basename(worktree.replace(/\/+$/u, "")) || worktree;
+};
+var getWorkspaceKey = (projectId) => `project:${projectId}`;
+var getProjectIdFromWorkspaceKey = (workspaceKey) => {
+	return workspaceKey.startsWith("project:") ? workspaceKey.slice(8) : null;
+};
+var parseModelInfo = (value) => {
+	const parsed = parseJsonValue(value);
+	if (typeof parsed === "string") return {
+		id: parsed,
+		providerID: null,
+		raw: parsed,
+		variant: null
+	};
+	const model = asObject(parsed);
+	return {
+		id: asString(model?.id ?? null),
+		providerID: asString(model?.providerID ?? null),
+		raw: parsed,
+		variant: asString(model?.variant ?? null)
+	};
+};
+var formatModelLabel = (model) => {
+	if (typeof model.raw === "string") return cleanLabel(model.raw);
+	const id = cleanLabel(model.id);
+	const variant = cleanLabel(model.variant);
+	if (!id) return null;
+	return variant ? `${id} ${variant}` : id;
+};
+var toWorkspaceGroup = (row) => {
+	const label = getWorkspaceLabel(row.name, row.worktree);
+	return {
+		archivedSessionCount: row.archivedSessionCount,
+		key: getWorkspaceKey(row.projectId),
+		label,
+		lastActiveMs: row.lastActiveMs,
+		messageCount: row.messageCount,
+		partCount: row.partCount,
+		projectId: row.projectId,
+		sessionCount: row.sessionCount,
+		uri: pathToFileURL(row.worktree).href,
+		worktree: row.worktree
+	};
+};
+var toSessionSummary = (row) => {
+	const label = getWorkspaceLabel(row.projectName, row.worktree);
+	const model = parseModelInfo(row.model);
+	return {
+		agent: row.agent,
+		archivedAtMs: row.archivedAtMs,
+		cost: row.cost,
+		createdAtMs: row.createdAtMs,
+		directory: row.directory,
+		lastUpdatedAtMs: row.lastUpdatedAtMs,
+		messageCount: row.messageCount,
+		model,
+		modelLabel: formatModelLabel(model),
+		partCount: row.partCount,
+		path: row.path,
+		permission: row.permission,
+		projectId: row.projectId,
+		renderablePartCount: row.renderablePartCount,
+		sessionId: row.sessionId,
+		slug: row.slug,
+		summaryAdditions: row.summaryAdditions,
+		summaryDeletions: row.summaryDeletions,
+		summaryFiles: row.summaryFiles,
+		textPartCount: row.textPartCount,
+		title: cleanLabel(row.title) ?? row.sessionId,
+		tokensCacheRead: row.tokensCacheRead,
+		tokensCacheWrite: row.tokensCacheWrite,
+		tokensInput: row.tokensInput,
+		tokensOutput: row.tokensOutput,
+		tokensReasoning: row.tokensReasoning,
+		toolPartCount: row.toolPartCount,
+		totalTokens: row.tokensInput + row.tokensOutput + row.tokensReasoning + row.tokensCacheRead + row.tokensCacheWrite,
+		workspaceKey: getWorkspaceKey(row.projectId),
+		workspaceLabel: label,
+		worktree: row.worktree
+	};
+};
+var workspaceRowsQuery = `
+    SELECT
+        p.id AS projectId,
+        p.name AS name,
+        p.worktree AS worktree,
+        (
+            SELECT COUNT(*)
+            FROM session s
+            WHERE s.project_id = p.id AND ${MAIN_SESSION_FILTER}
+        ) AS sessionCount,
+        (
+            SELECT COUNT(*)
+            FROM session s
+            WHERE s.project_id = p.id AND ${MAIN_SESSION_FILTER} AND s.time_archived IS NOT NULL
+        ) AS archivedSessionCount,
+        (
+            SELECT COUNT(*)
+            FROM message m
+            JOIN session s ON s.id = m.session_id
+            WHERE s.project_id = p.id AND ${MAIN_SESSION_FILTER}
+        ) AS messageCount,
+        (
+            SELECT COUNT(*)
+            FROM part prt
+            JOIN session s ON s.id = prt.session_id
+            WHERE s.project_id = p.id AND ${MAIN_SESSION_FILTER}
+        ) AS partCount,
+        COALESCE((
+            SELECT MAX(s.time_updated)
+            FROM session s
+            WHERE s.project_id = p.id AND ${MAIN_SESSION_FILTER}
+        ), p.time_updated) AS lastActiveMs
+    FROM project p
+`;
+var sessionSelectQuery = `
+    SELECT
+        s.id AS sessionId,
+        s.project_id AS projectId,
+        p.name AS projectName,
+        p.worktree AS worktree,
+        s.slug AS slug,
+        s.directory AS directory,
+        s.title AS title,
+        s.permission AS permission,
+        s.time_created AS createdAtMs,
+        s.time_updated AS lastUpdatedAtMs,
+        s.time_archived AS archivedAtMs,
+        s.path AS path,
+        s.agent AS agent,
+        s.model AS model,
+        s.cost AS cost,
+        s.tokens_input AS tokensInput,
+        s.tokens_output AS tokensOutput,
+        s.tokens_reasoning AS tokensReasoning,
+        s.tokens_cache_read AS tokensCacheRead,
+        s.tokens_cache_write AS tokensCacheWrite,
+        s.summary_files AS summaryFiles,
+        s.summary_additions AS summaryAdditions,
+        s.summary_deletions AS summaryDeletions,
+        (
+            SELECT COUNT(*)
+            FROM message m
+            WHERE m.session_id = s.id
+        ) AS messageCount,
+        (
+            SELECT COUNT(*)
+            FROM part prt
+            WHERE prt.session_id = s.id
+        ) AS partCount,
+        (
+            SELECT COUNT(*)
+            FROM part prt
+            WHERE prt.session_id = s.id AND json_extract(prt.data, '$.type') = 'text'
+        ) AS textPartCount,
+        (
+            SELECT COUNT(*)
+            FROM part prt
+            WHERE prt.session_id = s.id AND json_extract(prt.data, '$.type') = 'tool'
+        ) AS toolPartCount,
+        (
+            SELECT COUNT(*)
+            FROM part prt
+            WHERE prt.session_id = s.id
+              AND (
+                (
+                    json_extract(prt.data, '$.type') IN ('text', 'reasoning')
+                    AND trim(COALESCE(json_extract(prt.data, '$.text'), '')) <> ''
+                )
+                OR json_extract(prt.data, '$.type') = 'tool'
+              )
+        ) AS renderablePartCount
+    FROM session s
+    JOIN project p ON p.id = s.project_id
+`;
+var listOpenCodeWorkspaceGroups = async (dbPath = resolveOpenCodeDbPath()) => {
+	if (!await pathExists(dbPath)) return [];
+	const db = openOpenCodeReadonlyDb(dbPath);
+	try {
+		return db.query(`${workspaceRowsQuery} ORDER BY lastActiveMs DESC, p.worktree ASC`).all().map(toWorkspaceGroup);
+	} finally {
+		db.close();
+	}
+};
+var readSessionSummaries = (db, whereSql, params) => {
+	return db.query(`${sessionSelectQuery} WHERE ${whereSql} ORDER BY s.time_updated DESC, s.title ASC`).all(...params).map(toSessionSummary);
+};
+var listOpenCodeSessionsForGroup = async (workspaceKey, dbPath = resolveOpenCodeDbPath()) => {
+	const projectId = getProjectIdFromWorkspaceKey(workspaceKey);
+	if (!projectId || !await pathExists(dbPath)) return [];
+	const db = openOpenCodeReadonlyDb(dbPath);
+	try {
+		return readSessionSummaries(db, `s.project_id = ? AND ${MAIN_SESSION_FILTER}`, [projectId]);
+	} finally {
+		db.close();
+	}
+};
+var readOpenCodeSessionSummary = (db, sessionId) => {
+	return readSessionSummaries(db, `s.id = ? AND ${MAIN_SESSION_FILTER}`, [sessionId])[0] ?? null;
+};
+var getMessageRole = (raw) => asString(raw.role ?? null) ?? "unknown";
+var toPartType = (value) => {
+	switch (value) {
+		case "reasoning":
+		case "step-finish":
+		case "step-start":
+		case "text":
+		case "tool": return value;
+		default: return "unknown";
+	}
+};
+var formatJsonLike = (value) => {
+	if (value === void 0 || value === null) return null;
+	if (typeof value === "string") return value;
+	return JSON.stringify(value, null, 2);
+};
+var parseTimeMs = (raw, key) => {
+	return asNumber(asObject(raw.time ?? null)?.[key] ?? null);
+};
+var parseToolTimeMs = (raw, key) => {
+	return asNumber((asObject(asObject(raw.state ?? null)?.time ?? null) ?? asObject(raw.time ?? null))?.[key] ?? null);
+};
+var parseStepTokens = (value) => {
+	const tokens = asObject(value ?? null);
+	if (!tokens) return null;
+	const cache = asObject(tokens.cache ?? null);
+	return {
+		cacheRead: asNumber(cache?.read ?? null) ?? 0,
+		cacheWrite: asNumber(cache?.write ?? null) ?? 0,
+		input: asNumber(tokens.input ?? null) ?? 0,
+		output: asNumber(tokens.output ?? null) ?? 0,
+		reasoning: asNumber(tokens.reasoning ?? null) ?? 0,
+		total: asNumber(tokens.total ?? null) ?? 0
+	};
+};
+var parseTextOpenCodePart = (base) => ({
+	...base,
+	endTimeMs: parseTimeMs(base.raw, "end"),
+	startTimeMs: parseTimeMs(base.raw, "start"),
+	text: asString(base.raw.text ?? null) ?? ""
+});
+var parseToolOpenCodePart = (base) => {
+	const state = asObject(base.raw.state ?? null);
+	return {
+		...base,
+		argumentsText: formatJsonLike(state?.input),
+		callId: asString(base.raw.callID ?? null) ?? asString(base.raw.callId ?? null),
+		endTimeMs: parseToolTimeMs(base.raw, "end"),
+		outputText: formatJsonLike(state?.output),
+		startTimeMs: parseToolTimeMs(base.raw, "start"),
+		status: asString(state?.status ?? null),
+		title: asString(state?.title ?? null),
+		toolName: asString(base.raw.tool ?? null) ?? "unknown"
+	};
+};
+var parseStepFinishOpenCodePart = (base) => ({
+	...base,
+	reason: asString(base.raw.reason ?? null),
+	snapshot: asString(base.raw.snapshot ?? null),
+	tokens: parseStepTokens(base.raw.tokens)
+});
+var parseStepStartOpenCodePart = (base) => ({
+	...base,
+	snapshot: asString(base.raw.snapshot ?? null)
+});
+var parseOpenCodePartByType = (base) => {
+	switch (base.type) {
+		case "reasoning":
+		case "text": return parseTextOpenCodePart(base);
+		case "tool": return parseToolOpenCodePart(base);
+		case "step-finish": return parseStepFinishOpenCodePart(base);
+		case "step-start": return parseStepStartOpenCodePart(base);
+		case "unknown": return base;
+	}
+};
+var parseOpenCodePart = (row, role) => {
+	const raw = parseJsonObject(row.data);
+	return parseOpenCodePartByType({
+		createdAtMs: row.timeCreated,
+		messageId: row.messageId,
+		partId: row.partId,
+		raw,
+		role,
+		type: toPartType(raw.type),
+		updatedAtMs: row.timeUpdated
+	});
+};
+var isRenderablePart = (part) => {
+	if (part.type === "text" || part.type === "reasoning") {
+		const { reasoningBlocks, visibleText } = splitOpenCodeThinkTaggedText(part.text ?? "");
+		return Boolean(visibleText.trim() || reasoningBlocks.length > 0);
+	}
+	if (part.type === "tool") return Boolean(part.toolName || part.outputText?.trim() || part.argumentsText?.trim());
+	return false;
+};
+var readMessages = (db, sessionId) => {
+	const messageRows = db.query(`SELECT id AS messageId, time_created AS timeCreated, time_updated AS timeUpdated, data
+             FROM message
+             WHERE session_id = ?
+             ORDER BY time_created ASC, id ASC`).all(sessionId);
+	const partRows = db.query(`SELECT id AS partId, message_id AS messageId, time_created AS timeCreated, time_updated AS timeUpdated, data
+             FROM part
+             WHERE session_id = ?
+             ORDER BY time_created ASC, id ASC`).all(sessionId);
+	const partsByMessageId = /* @__PURE__ */ new Map();
+	for (const part of partRows) {
+		const parts = partsByMessageId.get(part.messageId) ?? [];
+		parts.push(part);
+		partsByMessageId.set(part.messageId, parts);
+	}
+	return messageRows.map((message) => {
+		const raw = parseJsonObject(message.data);
+		const role = getMessageRole(raw);
+		const parts = (partsByMessageId.get(message.messageId) ?? []).map((part) => parseOpenCodePart(part, role));
+		return {
+			createdAtMs: message.timeCreated,
+			messageId: message.messageId,
+			parts,
+			raw,
+			role,
+			updatedAtMs: message.timeUpdated
+		};
+	});
+};
+var readOpenCodeSessionTranscript = async (dbPath, sessionId) => {
+	if (!await pathExists(dbPath)) return null;
+	const db = openOpenCodeReadonlyDb(dbPath);
+	try {
+		const session = readOpenCodeSessionSummary(db, sessionId);
+		if (!session) return null;
+		const messages = readMessages(db, sessionId);
+		return {
+			messages,
+			partCount: messages.reduce((total, message) => total + message.parts.length, 0),
+			renderablePartCount: messages.reduce((total, message) => total + message.parts.filter(isRenderablePart).length, 0),
+			session
+		};
+	} finally {
+		db.close();
+	}
+};
+//#endregion
+export { listOpenCodeSessionsForGroup, listOpenCodeWorkspaceGroups, readOpenCodeSessionTranscript, resolveOpenCodeDbPath };

package/apps/ui/dist/server/assets/opencode-queries-BeNYXnQv.js

@@ -0,0 +1,50 @@
+import { t as createServerFn } from "../server.js";
+import { t as isRetryableSqliteError } from "./sqlite-error-LZDrnxdd.js";
+import { t as createSsrRpc } from "./createSsrRpc-C754NPki.js";
+import { z } from "zod";
+import { queryOptions } from "@tanstack/react-query";
+//#region src/lib/opencode-server.ts
+var workspaceSchema = z.object({ workspaceKey: z.string().min(1) });
+var sessionSchema = z.object({ sessionId: z.string().min(1) });
+var exportSessionSchema = z.object({
+	includeCommentary: z.boolean().default(true),
+	includeMetadata: z.boolean().default(true),
+	includeTools: z.boolean().default(true),
+	outputFormat: z.enum(["md", "txt"]).default("md"),
+	sessionId: z.string().min(1),
+	zipArchive: z.boolean().default(false)
+});
+var listOpenCodeWorkspacesFn = createServerFn({ method: "GET" }).handler(createSsrRpc("1579290293aa3c05864abeb16b20e7fbe85fe73b2518d8ba75dbc536dfc02b88"));
+var listOpenCodeSessionsFn = createServerFn({ method: "GET" }).validator(workspaceSchema).handler(createSsrRpc("1d8e6aec1907ff012d654cbfaa89e559078a0c2d80a02f4b257d9a179a002e36"));
+var getOpenCodeSessionDetailFn = createServerFn({ method: "GET" }).validator(sessionSchema).handler(createSsrRpc("0fdecc913045cc27ae7462cd3c143af926650dece043ca1a111e0e83a3cd327b"));
+var exportOpenCodeSessionFn = createServerFn({ method: "POST" }).validator(exportSessionSchema).handler(createSsrRpc("c051a060ff7f4d39e308fd586d9f81f576b53e96f37bdc56dd80112679f01218"));
+//#endregion
+//#region src/lib/opencode-queries.ts
+var retrySqliteQuery = (failureCount, error) => {
+	return failureCount < 3 && isRetryableSqliteError(error);
+};
+var retryDelay = (attemptIndex) => {
+	return [150, 400][attemptIndex] ?? 800;
+};
+var openCodeWorkspacesQueryOptions = () => queryOptions({
+	queryFn: () => listOpenCodeWorkspacesFn(),
+	queryKey: ["opencode-workspaces"],
+	retry: retrySqliteQuery,
+	retryDelay
+});
+var openCodeSessionsQueryOptions = (workspaceKey) => queryOptions({
+	enabled: workspaceKey !== null,
+	queryFn: () => listOpenCodeSessionsFn({ data: { workspaceKey: workspaceKey ?? "" } }),
+	queryKey: ["opencode-sessions", workspaceKey ?? "none"],
+	retry: retrySqliteQuery,
+	retryDelay
+});
+var openCodeSessionDetailQueryOptions = (sessionId) => queryOptions({
+	enabled: sessionId !== null,
+	queryFn: () => getOpenCodeSessionDetailFn({ data: { sessionId: sessionId ?? "" } }),
+	queryKey: ["opencode-session", sessionId ?? "none"],
+	retry: retrySqliteQuery,
+	retryDelay
+});
+//#endregion
+export { exportOpenCodeSessionFn as i, openCodeSessionsQueryOptions as n, openCodeWorkspacesQueryOptions as r, openCodeSessionDetailQueryOptions as t };

package/apps/ui/dist/server/assets/opencode-server-BpQ_kRze.js

@@ -0,0 +1,72 @@
+import { t as createServerFn } from "../server.js";
+import { t as createServerRpc } from "./createServerRpc-CF_DEwnm.js";
+import { t as renderSourceSessionDownload } from "./source-session-export-server-DNutCawb.js";
+import { z } from "zod";
+//#region src/lib/opencode-server.ts?tss-serverfn-split
+var workspaceSchema = z.object({ workspaceKey: z.string().min(1) });
+var sessionSchema = z.object({ sessionId: z.string().min(1) });
+var exportSessionSchema = z.object({
+	includeCommentary: z.boolean().default(true),
+	includeMetadata: z.boolean().default(true),
+	includeTools: z.boolean().default(true),
+	outputFormat: z.enum(["md", "txt"]).default("md"),
+	sessionId: z.string().min(1),
+	zipArchive: z.boolean().default(false)
+});
+var listOpenCodeWorkspacesFn_createServerFn_handler = createServerRpc({
+	id: "1579290293aa3c05864abeb16b20e7fbe85fe73b2518d8ba75dbc536dfc02b88",
+	name: "listOpenCodeWorkspacesFn",
+	filename: "src/lib/opencode-server.ts"
+}, (opts) => listOpenCodeWorkspacesFn.__executeServer(opts));
+var listOpenCodeWorkspacesFn = createServerFn({ method: "GET" }).handler(listOpenCodeWorkspacesFn_createServerFn_handler, async () => {
+	const { listOpenCodeWorkspaceGroups } = await import("./opencode-db-BM7KjOzc.js");
+	return listOpenCodeWorkspaceGroups();
+});
+var listOpenCodeSessionsFn_createServerFn_handler = createServerRpc({
+	id: "1d8e6aec1907ff012d654cbfaa89e559078a0c2d80a02f4b257d9a179a002e36",
+	name: "listOpenCodeSessionsFn",
+	filename: "src/lib/opencode-server.ts"
+}, (opts) => listOpenCodeSessionsFn.__executeServer(opts));
+var listOpenCodeSessionsFn = createServerFn({ method: "GET" }).validator(workspaceSchema).handler(listOpenCodeSessionsFn_createServerFn_handler, async ({ data }) => {
+	const { listOpenCodeSessionsForGroup } = await import("./opencode-db-BM7KjOzc.js");
+	return listOpenCodeSessionsForGroup(data.workspaceKey);
+});
+var loadOpenCodeSessionTranscript = async (sessionId) => {
+	const { readOpenCodeSessionTranscript, resolveOpenCodeDbPath } = await import("./opencode-db-BM7KjOzc.js");
+	const transcript = await readOpenCodeSessionTranscript(resolveOpenCodeDbPath(), sessionId);
+	if (!transcript) throw new Error(`OpenCode session not found: ${sessionId}`);
+	return transcript;
+};
+var getOpenCodeSessionDetailFn_createServerFn_handler = createServerRpc({
+	id: "0fdecc913045cc27ae7462cd3c143af926650dece043ca1a111e0e83a3cd327b",
+	name: "getOpenCodeSessionDetailFn",
+	filename: "src/lib/opencode-server.ts"
+}, (opts) => getOpenCodeSessionDetailFn.__executeServer(opts));
+var getOpenCodeSessionDetailFn = createServerFn({ method: "GET" }).validator(sessionSchema).handler(getOpenCodeSessionDetailFn_createServerFn_handler, async ({ data }) => {
+	return loadOpenCodeSessionTranscript(data.sessionId);
+});
+var exportOpenCodeSessionFn_createServerFn_handler = createServerRpc({
+	id: "c051a060ff7f4d39e308fd586d9f81f576b53e96f37bdc56dd80112679f01218",
+	name: "exportOpenCodeSessionFn",
+	filename: "src/lib/opencode-server.ts"
+}, (opts) => exportOpenCodeSessionFn.__executeServer(opts));
+var exportOpenCodeSessionFn = createServerFn({ method: "POST" }).validator(exportSessionSchema).handler(exportOpenCodeSessionFn_createServerFn_handler, async ({ data }) => {
+	const { renderOpenCodeTranscript } = await import("./opencode-transcript-BNTcGNym.js");
+	const transcript = await loadOpenCodeSessionTranscript(data.sessionId);
+	const content = renderOpenCodeTranscript(transcript, {
+		includeCommentary: data.includeCommentary,
+		includeMetadata: data.includeMetadata,
+		includeTools: data.includeTools,
+		outputFormat: data.outputFormat
+	});
+	if (!content) throw new Error(`OpenCode session has no exportable content: ${data.sessionId}`);
+	return renderSourceSessionDownload({
+		content,
+		fallbackBaseName: "opencode-session",
+		fileBaseName: transcript.session.title || transcript.session.slug || transcript.session.sessionId,
+		outputFormat: data.outputFormat,
+		zipArchive: data.zipArchive
+	});
+});
+//#endregion
+export { exportOpenCodeSessionFn_createServerFn_handler, getOpenCodeSessionDetailFn_createServerFn_handler, listOpenCodeSessionsFn_createServerFn_handler, listOpenCodeWorkspacesFn_createServerFn_handler };