@ottocode/server 0.1.193 → 0.1.194

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/server",
-	"version": "0.1.193",
+	"version": "0.1.194",
 	"description": "HTTP API server for ottocode",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -29,8 +29,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@ottocode/sdk": "0.1.193",
-		"@ottocode/database": "0.1.193",
+		"@ottocode/sdk": "0.1.194",
+		"@ottocode/database": "0.1.194",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/index.ts

@@ -20,6 +20,7 @@ import { registerSessionApprovalRoute } from './routes/session-approval.ts';
 import { registerSetuRoutes } from './routes/setu.ts';
 import { registerAuthRoutes } from './routes/auth.ts';
 import { registerTunnelRoutes } from './routes/tunnel.ts';
+import { registerProviderUsageRoutes } from './routes/provider-usage.ts';
 import type { AgentConfigEntry } from './runtime/agent/registry.ts';
 
 const globalTerminalManager = new TerminalManager();
@@ -76,6 +77,7 @@ function initApp() {
 	registerSetuRoutes(app);
 	registerAuthRoutes(app);
 	registerTunnelRoutes(app);
+	registerProviderUsageRoutes(app);
 
 	return app;
 }
@@ -148,6 +150,7 @@ export function createStandaloneApp(_config?: StandaloneAppConfig) {
 	registerSetuRoutes(honoApp);
 	registerAuthRoutes(honoApp);
 	registerTunnelRoutes(honoApp);
+	registerProviderUsageRoutes(honoApp);
 
 	return honoApp;
 }
@@ -248,6 +251,7 @@ export function createEmbeddedApp(config: EmbeddedAppConfig = {}) {
 	registerSetuRoutes(honoApp);
 	registerAuthRoutes(honoApp);
 	registerTunnelRoutes(honoApp);
+	registerProviderUsageRoutes(honoApp);
 
 	return honoApp;
 }

package/src/openapi/paths/git.ts

@@ -350,6 +350,52 @@ export const gitPaths = {
 			},
 		},
 	},
+	'/v1/git/pull': {
+		post: {
+			tags: ['git'],
+			operationId: 'pullChanges',
+			summary: 'Pull changes from remote',
+			description: 'Pulls changes from the configured remote repository',
+			requestBody: {
+				required: false,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								project: { type: 'string' },
+							},
+						},
+					},
+				},
+			},
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									status: { type: 'string', enum: ['ok'] },
+									data: {
+										type: 'object',
+										properties: {
+											output: { type: 'string' },
+										},
+										required: ['output'],
+									},
+								},
+								required: ['status', 'data'],
+							},
+						},
+					},
+				},
+				400: gitErrorResponse(),
+				500: gitErrorResponse(),
+			},
+		},
+	},
 	'/v1/git/restore': {
 		post: {
 			tags: ['git'],

package/src/routes/git/index.ts

@@ -5,6 +5,7 @@ import { registerDiffRoute } from './diff.ts';
 import { registerStagingRoutes } from './staging.ts';
 import { registerCommitRoutes } from './commit.ts';
 import { registerPushRoute } from './push.ts';
+import { registerPullRoute } from './pull.ts';
 
 export type { GitFile } from './types.ts';
 
@@ -15,4 +16,5 @@ export function registerGitRoutes(app: Hono) {
 	registerStagingRoutes(app);
 	registerCommitRoutes(app);
 	registerPushRoute(app);
+	registerPullRoute(app);
 }

package/src/routes/git/pull.ts

@@ -0,0 +1,98 @@
+import type { Hono } from 'hono';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { gitPullSchema } from './schemas.ts';
+import { validateAndGetGitRoot } from './utils.ts';
+
+const execFileAsync = promisify(execFile);
+
+export function registerPullRoute(app: Hono) {
+	app.post('/v1/git/pull', async (c) => {
+		try {
+			let body = {};
+			try {
+				body = await c.req.json();
+			} catch {
+				body = {};
+			}
+
+			const { project } = gitPullSchema.parse(body);
+
+			const requestedPath = project || process.cwd();
+
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
+
+			try {
+				const result = await execFileAsync('git', ['pull'], {
+					cwd: gitRoot,
+				});
+
+				return c.json({
+					status: 'ok',
+					data: {
+						output: result.stdout.trim() || result.stderr.trim(),
+					},
+				});
+			} catch (pullErr: unknown) {
+				const error = pullErr as {
+					message?: string;
+					stderr?: string;
+				};
+				const errorMessage = error.stderr || error.message || 'Failed to pull';
+
+				if (
+					errorMessage.includes('CONFLICT') ||
+					errorMessage.includes('merge conflict')
+				) {
+					return c.json(
+						{
+							status: 'error',
+							error: 'Merge conflicts detected. Resolve conflicts manually',
+							details: errorMessage,
+						},
+						400,
+					);
+				}
+
+				if (
+					errorMessage.includes('Permission denied') ||
+					errorMessage.includes('authentication')
+				) {
+					return c.json(
+						{
+							status: 'error',
+							error: 'Authentication failed. Check your git credentials',
+							details: errorMessage,
+						},
+						401,
+					);
+				}
+
+				return c.json(
+					{
+						status: 'error',
+						error: 'Failed to pull changes',
+						details: errorMessage,
+					},
+					500,
+				);
+			}
+		} catch (error) {
+			return c.json(
+				{
+					status: 'error',
+					error: error instanceof Error ? error.message : 'Failed to pull',
+				},
+				500,
+			);
+		}
+	});
+}

package/src/routes/git/schemas.ts

@@ -46,3 +46,7 @@ export const gitGenerateCommitMessageSchema = z.object({
 export const gitPushSchema = z.object({
 	project: z.string().optional(),
 });
+
+export const gitPullSchema = z.object({
+	project: z.string().optional(),
+});

package/src/routes/provider-usage.ts

@@ -0,0 +1,199 @@
+import type { Hono } from 'hono';
+import {
+	getAuth,
+	refreshToken,
+	refreshOpenAIToken,
+	type ProviderId,
+} from '@ottocode/sdk';
+import { logger } from '@ottocode/sdk';
+import { setAuth } from '@ottocode/sdk';
+import { serializeError } from '../runtime/errors/api-error.ts';
+import type { OAuth } from '@ottocode/sdk';
+
+async function ensureValidOAuth(
+	provider: ProviderId,
+): Promise<{ access: string; oauth: OAuth } | null> {
+	const projectRoot = process.cwd();
+	const auth = await getAuth(provider, projectRoot);
+	if (!auth || auth.type !== 'oauth') return null;
+
+	if (auth.access && auth.expires > Date.now()) {
+		return { access: auth.access, oauth: auth };
+	}
+
+	try {
+		const refreshFn = provider === 'openai' ? refreshOpenAIToken : refreshToken;
+		const newTokens = await refreshFn(auth.refresh);
+		const updated: OAuth = {
+			...auth,
+			access: newTokens.access,
+			refresh: newTokens.refresh,
+			expires: newTokens.expires,
+		};
+		await setAuth(provider, updated, projectRoot, 'global');
+		return { access: updated.access, oauth: updated };
+	} catch {
+		return { access: auth.access, oauth: auth };
+	}
+}
+
+async function fetchAnthropicUsage(access: string) {
+	const response = await fetch('https://api.anthropic.com/api/oauth/usage', {
+		headers: {
+			Authorization: `Bearer ${access}`,
+			'anthropic-beta': 'oauth-2025-04-20',
+			Accept: 'application/json',
+		},
+	});
+
+	if (!response.ok) {
+		throw new Error(`Anthropic usage API returned ${response.status}`);
+	}
+
+	const data = (await response.json()) as {
+		five_hour?: { utilization: number; resets_at: string | null };
+		seven_day?: { utilization: number; resets_at: string | null };
+		seven_day_sonnet?: { utilization: number; resets_at: string | null };
+		extra_usage?: {
+			is_enabled: boolean;
+			monthly_limit: number;
+			used_credits: number;
+			utilization: number | null;
+		};
+	};
+
+	return {
+		provider: 'anthropic' as const,
+		primaryWindow: data.five_hour
+			? {
+					usedPercent: data.five_hour.utilization,
+					windowSeconds: 18000,
+					resetsAt: data.five_hour.resets_at,
+				}
+			: null,
+		secondaryWindow: data.seven_day
+			? {
+					usedPercent: data.seven_day.utilization,
+					windowSeconds: 604800,
+					resetsAt: data.seven_day.resets_at,
+				}
+			: null,
+		sonnetWindow: data.seven_day_sonnet
+			? {
+					usedPercent: data.seven_day_sonnet.utilization,
+					resetsAt: data.seven_day_sonnet.resets_at,
+				}
+			: null,
+		extraUsage: data.extra_usage ?? null,
+		limitReached: (data.five_hour?.utilization ?? 0) >= 100,
+		raw: data,
+	};
+}
+
+async function fetchOpenAIUsage(access: string, accountId?: string) {
+	const headers: Record<string, string> = {
+		Authorization: `Bearer ${access}`,
+		Accept: '*/*',
+	};
+	if (accountId) {
+		headers['ChatGPT-Account-Id'] = accountId;
+	}
+	const response = await fetch('https://chatgpt.com/backend-api/wham/usage', {
+		headers,
+	});
+
+	if (!response.ok) {
+		throw new Error(`OpenAI usage API returned ${response.status}`);
+	}
+
+	const data = (await response.json()) as {
+		plan_type?: string;
+		rate_limit?: {
+			allowed: boolean;
+			limit_reached: boolean;
+			primary_window?: {
+				used_percent: number;
+				limit_window_seconds: number;
+				reset_after_seconds: number;
+				reset_at: number;
+			};
+			secondary_window?: {
+				used_percent: number;
+				limit_window_seconds: number;
+				reset_after_seconds: number;
+				reset_at: number;
+			} | null;
+		};
+		credits?: {
+			has_credits: boolean;
+			balance: number | null;
+		};
+	};
+
+	const rl = data.rate_limit;
+	return {
+		provider: 'openai' as const,
+		planType: data.plan_type ?? null,
+		primaryWindow: rl?.primary_window
+			? {
+					usedPercent: rl.primary_window.used_percent,
+					windowSeconds: rl.primary_window.limit_window_seconds,
+					resetsAt: new Date(rl.primary_window.reset_at * 1000).toISOString(),
+					resetAfterSeconds: rl.primary_window.reset_after_seconds,
+				}
+			: null,
+		secondaryWindow: rl?.secondary_window
+			? {
+					usedPercent: rl.secondary_window.used_percent,
+					windowSeconds: rl.secondary_window.limit_window_seconds,
+					resetsAt: new Date(rl.secondary_window.reset_at * 1000).toISOString(),
+					resetAfterSeconds: rl.secondary_window.reset_after_seconds,
+				}
+			: null,
+		credits: data.credits ?? null,
+		limitReached: rl?.limit_reached ?? false,
+		raw: data,
+	};
+}
+
+export function registerProviderUsageRoutes(app: Hono) {
+	app.get('/v1/provider-usage/:provider', async (c) => {
+		try {
+			const provider = c.req.param('provider') as ProviderId;
+
+			if (provider !== 'anthropic' && provider !== 'openai') {
+				return c.json(
+					{ error: { message: 'Usage not supported for this provider' } },
+					400,
+				);
+			}
+
+			const tokenResult = await ensureValidOAuth(provider);
+			if (!tokenResult) {
+				return c.json(
+					{
+						error: {
+							message: `No OAuth credentials for ${provider}. Usage is only available for OAuth-authenticated providers.`,
+						},
+					},
+					404,
+				);
+			}
+
+			const usage =
+				provider === 'anthropic'
+					? await fetchAnthropicUsage(tokenResult.access)
+					: await fetchOpenAIUsage(
+							tokenResult.access,
+							tokenResult.oauth.accountId,
+						);
+
+			return c.json(usage);
+		} catch (error) {
+			logger.error('Failed to fetch provider usage', error);
+			const errorResponse = serializeError(error);
+			const status = (errorResponse.error.status || 500) as 500;
+			return c.json(errorResponse, status);
+		}
+	});
+}

package/src/runtime/agent/runner.ts

@@ -307,7 +307,11 @@ async function runAssistant(opts: RunOpts) {
 
 		const wasTruncated = streamFinishReason === 'length';
 
-		const shouldContinue = !_finishObserved && (wasTruncated || fs);
+		const shouldContinue =
+			opts.provider === 'openai' &&
+			isOpenAIOAuth &&
+			!_finishObserved &&
+			(wasTruncated || fs);
 
 		if (shouldContinue) {
 			debugLog(