opencodekit 0.15.10 → 0.15.12

package/dist/template/.opencode/plugin/copilot-auth.ts

@@ -5,7 +5,11 @@
 
 import type { Plugin } from "@opencode-ai/plugin";
 
-const CLIENT_ID = "Iv1.b507a08c87ecfe98";
+const CLIENT_ID = "Ov23li8tweQw6odWQebz";
+
+// Add a small safety buffer when polling to avoid hitting the server
+// slightly too early due to clock skew / timer drift.
+const OAUTH_POLLING_SAFETY_MARGIN_MS = 3000; // 3 seconds
 
 const HEADERS = {
 	"User-Agent": "GitHubCopilotChat/0.35.0",
@@ -40,11 +44,12 @@ function getUrls(domain: string) {
 	return {
 		DEVICE_CODE_URL: `https://${domain}/login/device/code`,
 		ACCESS_TOKEN_URL: `https://${domain}/login/oauth/access_token`,
-		COPILOT_API_KEY_URL: `https://api.github.com/copilot_internal/v2/token`,
 	};
 }
 
-export const CopilotAuthPlugin: Plugin = async ({ client }) => {
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
 	return {
 		auth: {
 			provider: "github-copilot",
@@ -52,6 +57,11 @@ export const CopilotAuthPlugin: Plugin = async ({ client }) => {
 				const info = await getAuth();
 				if (!info || info.type !== "oauth") return {};
 
+				const enterpriseUrl = info.enterpriseUrl;
+				const baseURL = enterpriseUrl
+					? `https://copilot-api.${normalizeDomain(enterpriseUrl)}`
+					: undefined;
+
 				if (provider && provider.models) {
 					for (const model of Object.values(provider.models)) {
 						model.cost = {
@@ -62,71 +72,47 @@ export const CopilotAuthPlugin: Plugin = async ({ client }) => {
 								write: 0,
 							},
 						};
+
+						// Sync with official: Handle Claude routing and SDK mapping
+						const base =
+							baseURL ?? model.api.url ?? "https://api.githubcopilot.com";
+						const isClaude = model.id.includes("claude");
+
+						let url = base;
+						if (isClaude) {
+							if (!url.endsWith("/v1")) {
+								url = url.endsWith("/") ? `${url}v1` : `${url}/v1`;
+							}
+						}
+
+						model.api.url = url;
+						model.api.npm = isClaude
+							? "@ai-sdk/anthropic"
+							: "@ai-sdk/github-copilot";
 					}
 				}
 
-				const enterpriseUrl = info.enterpriseUrl;
-				const baseURL = enterpriseUrl
-					? `https://copilot-api.${normalizeDomain(enterpriseUrl)}`
-					: "https://api.githubcopilot.com";
-
 				return {
-					baseURL,
 					apiKey: "",
 					async fetch(input, init) {
 						const info = await getAuth();
-						if (info.type !== "oauth") return {};
-						if (!info.access) {
-							const domain = info.enterpriseUrl
-								? normalizeDomain(info.enterpriseUrl)
-								: "github.com";
-							const urls = getUrls(domain);
-
-							const response = await fetch(urls.COPILOT_API_KEY_URL, {
-								headers: {
-									Accept: "application/json",
-									Authorization: `Bearer ${info.refresh}`,
-									...HEADERS,
-								},
-							});
-
-							if (!response.ok) {
-								throw new Error(`Token refresh failed: ${response.status}`);
-							}
-
-							const tokenData = await response.json();
-
-							const saveProviderID = info.enterpriseUrl
-								? "github-copilot-enterprise"
-								: "github-copilot";
-							await client.auth.set({
-								path: {
-									id: saveProviderID,
-								},
-								body: {
-									type: "oauth",
-									refresh: info.refresh,
-									access: tokenData.token,
-									expires: tokenData.expires_at * 1000 - 5 * 60 * 1000,
-									...(info.enterpriseUrl && {
-										enterpriseUrl: info.enterpriseUrl,
-									}),
-								},
-							});
-							info.access = tokenData.token;
-						}
+						if (info.type !== "oauth") return fetch(input, init);
 
 						let isAgentCall = false;
 						let isVisionRequest = false;
 						try {
 							const body =
-								typeof init.body === "string"
+								typeof init?.body === "string"
 									? JSON.parse(init.body)
-									: init.body;
-							if (body?.messages) {
-								isAgentCall = body.messages.some(
-									(msg: any) =>
-										msg.role && ["tool", "assistant"].includes(msg.role),
+									: init?.body;
+
+							const url = input.toString();
+
+							// Completions API
+							if (body?.messages && url.includes("completions")) {
+								// Keep local logic: detect if any message is assistant/tool
+								isAgentCall = body.messages.some((msg: any) =>
+									["tool", "assistant"].includes(msg.role),
 								);
 								isVisionRequest = body.messages.some(
 									(msg: any) =>
@@ -135,34 +121,58 @@ export const CopilotAuthPlugin: Plugin = async ({ client }) => {
 								);
 							}
 
+							// Responses API
 							if (body?.input) {
-								const lastInput = body.input[body.input.length - 1];
-
-								const isAssistant = lastInput?.role === "assistant";
-								const hasAgentType = lastInput?.type
-									? RESPONSES_API_ALTERNATE_INPUT_TYPES.includes(lastInput.type)
-									: false;
-								isAgentCall = isAssistant || hasAgentType;
-
-								isVisionRequest =
-									Array.isArray(lastInput?.content) &&
-									lastInput.content.some(
-										(part: any) => part.type === "input_image",
-									);
+								isAgentCall = body.input.some(
+									(item: any) =>
+										item?.role === "assistant" ||
+										(item?.type &&
+											RESPONSES_API_ALTERNATE_INPUT_TYPES.includes(item.type)),
+								);
+
+								isVisionRequest = body.input.some(
+									(item: any) =>
+										Array.isArray(item?.content) &&
+										item.content.some(
+											(part: any) => part.type === "input_image",
+										),
+								);
+							}
+
+							// Messages API (Anthropic style)
+							if (body?.messages && !url.includes("completions")) {
+								isAgentCall = body.messages.some((msg: any) =>
+									["tool", "assistant"].includes(msg.role),
+								);
+								isVisionRequest = body.messages.some(
+									(item: any) =>
+										Array.isArray(item?.content) &&
+										item.content.some(
+											(part: any) =>
+												part?.type === "image" ||
+												(part?.type === "tool_result" &&
+													Array.isArray(part?.content) &&
+													part.content.some(
+														(nested: any) => nested?.type === "image",
+													)),
+										),
+								);
 							}
 						} catch {}
 
-						const headers = {
-							...init.headers,
+						const headers: Record<string, string> = {
+							"x-initiator": isAgentCall ? "agent" : "user",
+							...(init?.headers as Record<string, string>),
 							...HEADERS,
-							Authorization: `Bearer ${info.access}`,
+							Authorization: `Bearer ${info.refresh}`,
 							"Openai-Intent": "conversation-edits",
-							"X-Initiator": isAgentCall ? "agent" : "user",
 						};
+
 						if (isVisionRequest) {
 							headers["Copilot-Vision-Request"] = "true";
 						}
 
+						// Official only deletes lowercase "authorization"
 						delete headers["x-api-key"];
 						delete headers["authorization"];
 
@@ -286,7 +296,7 @@ export const CopilotAuthPlugin: Plugin = async ({ client }) => {
 										} = {
 											type: "success",
 											refresh: data.access_token,
-											access: "",
+											access: data.access_token,
 											expires: 0,
 										};
 
@@ -299,16 +309,33 @@ export const CopilotAuthPlugin: Plugin = async ({ client }) => {
 									}
 
 									if (data.error === "authorization_pending") {
-										await new Promise((resolve) =>
-											setTimeout(resolve, deviceData.interval * 1000),
+										await sleep(
+											deviceData.interval * 1000 +
+												OAUTH_POLLING_SAFETY_MARGIN_MS,
 										);
 										continue;
 									}
 
+									if (data.error === "slow_down") {
+										// Based on the RFC spec, we must add 5 seconds to our current polling interval.
+										let newInterval = (deviceData.interval + 5) * 1000;
+
+										if (
+											data.interval &&
+											typeof data.interval === "number" &&
+											data.interval > 0
+										) {
+											newInterval = data.interval * 1000;
+										}
+
+										await sleep(newInterval + OAUTH_POLLING_SAFETY_MARGIN_MS);
+										continue;
+									}
+
 									if (data.error) return { type: "failed" };
 
-									await new Promise((resolve) =>
-										setTimeout(resolve, deviceData.interval * 1000),
+									await sleep(
+										deviceData.interval * 1000 + OAUTH_POLLING_SAFETY_MARGIN_MS,
 									);
 									continue;
 								}

package/dist/template/.opencode/plugin/swarm-enforcer.ts

@@ -0,0 +1,297 @@
+/**
+ * Swarm Enforcer Plugin
+ *
+ * Beads is the single source of truth for the swarm board.
+ * This plugin nudges agents to:
+ * - Claim a Beads task before making code changes
+ * - Ensure `spec.md` exists for in-progress tasks
+ * - Close/sync in-progress work at session end
+ *
+ * This plugin is intentionally non-destructive: it never runs `bd update/close/sync`.
+ */
+
+import fsPromises from "node:fs/promises";
+import path from "node:path";
+import type { Plugin } from "@opencode-ai/plugin";
+
+type BeadsIssue = {
+	id: string;
+	title?: string;
+	status?: string;
+};
+
+const BEADS_DIR = ".beads";
+const ISSUES_FILE = "issues.jsonl";
+
+const CODE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".py",
+	".go",
+	".rs",
+	".java",
+	".c",
+	".cpp",
+	".h",
+	".hpp",
+];
+
+const WORK_INTENT_PATTERNS = [
+	/\b(implement|fix|refactor|add|remove|delete|update|change|modify|create|build)\b/i,
+	/\b(edit|patch)\b/i,
+];
+
+function looksLikeWorkIntent(text: string): boolean {
+	return WORK_INTENT_PATTERNS.some((p) => p.test(text));
+}
+
+function isCodeFile(filePath: string): boolean {
+	return CODE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
+}
+
+function isIgnoredPath(repoDir: string, filePath: string): boolean {
+	const absPath = path.isAbsolute(filePath)
+		? filePath
+		: path.join(repoDir, filePath);
+	const rel = path.relative(repoDir, absPath);
+
+	// Outside repo: ignore
+	if (rel.startsWith("..")) return true;
+
+	const normalized = rel.replace(/\\/g, "/");
+	return (
+		normalized.startsWith("node_modules/") ||
+		normalized.startsWith("dist/") ||
+		normalized.startsWith(".beads/") ||
+		normalized.startsWith(".git/")
+	);
+}
+
+function summarizeIssues(issues: BeadsIssue[], limit = 5): string {
+	return issues
+		.slice(0, limit)
+		.map((i) => `${i.id}${i.title ? `: ${i.title}` : ""}`)
+		.join("\n");
+}
+
+async function readIssuesJsonl(repoDir: string): Promise<BeadsIssue[]> {
+	const issuesPath = path.join(repoDir, BEADS_DIR, ISSUES_FILE);
+
+	let content: string;
+	try {
+		content = await fsPromises.readFile(issuesPath, "utf-8");
+	} catch {
+		return [];
+	}
+
+	const issues: BeadsIssue[] = [];
+	const lines = content.split(/\r?\n/);
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const parsed = JSON.parse(trimmed);
+			if (parsed && typeof parsed.id === "string") {
+				issues.push({
+					id: parsed.id,
+					title: typeof parsed.title === "string" ? parsed.title : undefined,
+					status: typeof parsed.status === "string" ? parsed.status : undefined,
+				});
+			}
+		} catch {
+			// Ignore malformed JSONL lines
+		}
+	}
+
+	return issues;
+}
+
+async function specExists(repoDir: string, issueId: string): Promise<boolean> {
+	const specPath = path.join(
+		repoDir,
+		BEADS_DIR,
+		"artifacts",
+		issueId,
+		"spec.md",
+	);
+	try {
+		await fsPromises.access(specPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function buildNudge(params: {
+	inProgress: BeadsIssue[];
+	missingSpec: BeadsIssue[];
+}): string {
+	const { inProgress, missingSpec } = params;
+
+	if (inProgress.length === 0) {
+		return `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+⚡ [SWARM PROTOCOL]
+
+Beads is the swarm board. Before any code changes:
+
+1) Pick a task: \`bd ready\` (or \`bd list\`)
+2) Inspect: \`bd show <id>\`
+3) Claim: \`bd update <id> --status=in_progress\`
+
+Then proceed with work and collect verification evidence.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+	}
+
+	if (missingSpec.length > 0) {
+		return `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+⚡ [SWARM PROTOCOL]
+
+In-progress Beads exist, but \`spec.md\` is missing for:
+
+${summarizeIssues(missingSpec)}
+
+Create \`.beads/artifacts/<id>/spec.md\` before implementation.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+	}
+
+	return "";
+}
+
+export const SwarmEnforcer: Plugin = async ({ client, directory }) => {
+	const repoDir = directory || process.cwd();
+	let lastStateAt = 0;
+	let cachedInProgress: BeadsIssue[] = [];
+	let cachedMissingSpec: BeadsIssue[] = [];
+
+	const refreshState = async () => {
+		const now = Date.now();
+		if (now - lastStateAt < 1500) return;
+		lastStateAt = now;
+
+		const issues = await readIssuesJsonl(repoDir);
+		const inProgress = issues.filter((i) => i.status === "in_progress");
+
+		const missingSpec: BeadsIssue[] = [];
+		for (const issue of inProgress.slice(0, 10)) {
+			if (!(await specExists(repoDir, issue.id))) {
+				missingSpec.push(issue);
+			}
+		}
+
+		cachedInProgress = inProgress;
+		cachedMissingSpec = missingSpec;
+	};
+
+	const showToast = async (
+		title: string,
+		message: string,
+		variant: "info" | "success" | "warning" | "error" = "info",
+	) => {
+		try {
+			await client.tui.showToast({
+				body: {
+					title,
+					message,
+					variant,
+					duration: variant === "error" ? 8000 : 5000,
+				},
+			});
+		} catch {
+			// If toast is unavailable, fail silently
+		}
+	};
+
+	return {
+		// Nudge early when user expresses implementation intent
+		"chat.message": async (input, output) => {
+			const { sessionID, messageID } = input;
+			const { message, parts } = output;
+			if (message.role !== "user") return;
+
+			const fullText = parts
+				.filter((p) => p.type === "text" && !("synthetic" in p && p.synthetic))
+				.map((p) => ("text" in p ? p.text : ""))
+				.join(" ");
+
+			if (!looksLikeWorkIntent(fullText)) return;
+
+			await refreshState();
+
+			const nudge = buildNudge({
+				inProgress: cachedInProgress,
+				missingSpec: cachedMissingSpec,
+			});
+			if (!nudge) return;
+
+			parts.push({
+				id: `swarm-nudge-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+				sessionID,
+				messageID: messageID || "",
+				type: "text",
+				text: nudge,
+				synthetic: true,
+			} as import("@opencode-ai/sdk").Part);
+		},
+
+		// Warn if code gets edited while no task is claimed / spec missing
+		"file.edited": async ({ event }) => {
+			const filePath = event.properties?.file || event.properties?.path;
+			if (!filePath || typeof filePath !== "string") return;
+			if (isIgnoredPath(repoDir, filePath)) return;
+
+			const absPath = path.isAbsolute(filePath)
+				? filePath
+				: path.join(repoDir, filePath);
+
+			if (!isCodeFile(absPath)) return;
+
+			await refreshState();
+
+			if (cachedInProgress.length === 0) {
+				await showToast(
+					"Swarm: No task claimed",
+					"Beads is the board. Claim a task before code edits (bd ready/show/update).",
+					"warning",
+				);
+				return;
+			}
+
+			if (cachedMissingSpec.length > 0) {
+				await showToast(
+					"Swarm: Missing spec.md",
+					`Create .beads/artifacts/<id>/spec.md for: ${cachedMissingSpec
+						.slice(0, 3)
+						.map((i) => i.id)
+						.join(", ")}`,
+					"warning",
+				);
+			}
+		},
+
+		// Session end reminder: close/sync if tasks still in progress
+		"session.idle": async () => {
+			await refreshState();
+			if (cachedInProgress.length === 0) return;
+
+			const list = cachedInProgress
+				.slice(0, 5)
+				.map((i) => i.id)
+				.join(", ");
+			await showToast(
+				"Swarm: Work still in progress",
+				`In-progress Beads: ${list}. Close with bd close + bd sync when done.`,
+				"info",
+			);
+		},
+	};
+};
+
+export default SwarmEnforcer;