@dmrlzz/davecode 0.5.1 → 0.5.3

package/dist/{chunk-JFWMLYV7.js → chunk-YSD6W27K.js}

@@ -1,3 +1,6 @@
+import {
+  openBrowser
+} from "./chunk-732GIHRQ.js";
 import {
   ConfigError,
   PROVIDER_KINDS,
@@ -11,6 +14,7 @@ import {
   WorkspaceLock,
   apiConfigIssues,
   connectionMethod,
+  createAccountControl,
   createEngine,
   createGoalService,
   createRunner,
@@ -21,7 +25,7 @@ import {
   newId2,
   routeSchema,
   taskIdSchema
-} from "./chunk-HENE4DA6.js";
+} from "./chunk-ING5HCIO.js";
 
 // src/runtime.ts
 import { existsSync as existsSync3 } from "fs";
@@ -37,13 +41,14 @@ import { resolve } from "path";
 import cors from "@fastify/cors";
 import fastifyStatic from "@fastify/static";
 import Fastify from "fastify";
-import { z as z4 } from "zod";
 import { z } from "zod";
+import { z as z5 } from "zod";
 import { z as z2 } from "zod";
 import { z as z3 } from "zod";
-import { z as z5 } from "zod";
-import { Readable } from "stream";
+import { z as z4 } from "zod";
 import { z as z6 } from "zod";
+import { Readable } from "stream";
+import { z as z7 } from "zod";
 function sendApiError(reply, status, code, message, extra = {}) {
   return reply.code(status).send({ error: { message, code, ...extra } });
 }
@@ -92,55 +97,81 @@ function describeRoutingError(err) {
     body: { message: "Internal gateway error", type: "api_error", code: "internal_error" }
   };
 }
-var providerKind = z.enum(PROVIDER_KINDS);
-var contentPart = z.discriminatedUnion("type", [
-  z.object({ type: z.literal("text"), text: z.string() }),
-  z.object({
-    type: z.literal("image_url"),
-    image_url: z.object({
-      url: z.string(),
-      detail: z.enum(["auto", "low", "high"]).optional()
+var loginSchema = z.object({ provider: z.enum(["google", "github"]).optional() });
+function registerAccountRoutes(app, account) {
+  if (!account) return;
+  app.get("/api/account", async (_request, reply) => {
+    reply.header("Cache-Control", "no-store");
+    return account.state();
+  });
+  app.post("/api/account/login", async (request, reply) => {
+    const parsed = loginSchema.safeParse(request.body ?? {});
+    if (!parsed.success)
+      return sendApiError(reply, 400, "invalid_body", "Unknown sign-in provider.");
+    try {
+      return reply.code(202).send(await account.login(parsed.data.provider));
+    } catch {
+      return sendApiError(reply, 502, "account_unavailable", "Could not start the sign-in.");
+    }
+  });
+  app.post("/api/account/cancel", async (_request, reply) => {
+    await account.cancel();
+    return reply.code(204).send();
+  });
+  app.post("/api/account/logout", async (_request, reply) => {
+    await account.logout();
+    return reply.code(204).send();
+  });
+}
+var providerKind = z2.enum(PROVIDER_KINDS);
+var contentPart = z2.discriminatedUnion("type", [
+  z2.object({ type: z2.literal("text"), text: z2.string() }),
+  z2.object({
+    type: z2.literal("image_url"),
+    image_url: z2.object({
+      url: z2.string(),
+      detail: z2.enum(["auto", "low", "high"]).optional()
     })
   })
 ]);
-var toolCall = z.object({
-  id: z.string(),
-  type: z.literal("function"),
-  function: z.object({ name: z.string(), arguments: z.string() })
+var toolCall = z2.object({
+  id: z2.string(),
+  type: z2.literal("function"),
+  function: z2.object({ name: z2.string(), arguments: z2.string() })
 });
-var chatMessage = z.object({
-  role: z.enum(["system", "user", "assistant", "tool"]),
-  content: z.union([z.string(), z.array(contentPart), z.null()]),
-  name: z.string().optional(),
-  tool_call_id: z.string().optional(),
-  tool_calls: z.array(toolCall).optional()
+var chatMessage = z2.object({
+  role: z2.enum(["system", "user", "assistant", "tool"]),
+  content: z2.union([z2.string(), z2.array(contentPart), z2.null()]),
+  name: z2.string().optional(),
+  tool_call_id: z2.string().optional(),
+  tool_calls: z2.array(toolCall).optional()
 });
-var chatRequestSchema = z.object({
-  model: z.string().min(1),
-  messages: z.array(chatMessage).min(1),
-  stream: z.boolean().optional(),
-  temperature: z.number().min(0).max(2).optional(),
-  top_p: z.number().min(0).max(1).optional(),
-  max_tokens: z.number().int().positive().optional(),
-  stop: z.union([z.string(), z.array(z.string())]).optional(),
-  tools: z.array(
-    z.object({
-      type: z.literal("function"),
-      function: z.object({
-        name: z.string(),
-        description: z.string().optional(),
-        parameters: z.record(z.string(), z.unknown()).optional()
+var chatRequestSchema = z2.object({
+  model: z2.string().min(1),
+  messages: z2.array(chatMessage).min(1),
+  stream: z2.boolean().optional(),
+  temperature: z2.number().min(0).max(2).optional(),
+  top_p: z2.number().min(0).max(1).optional(),
+  max_tokens: z2.number().int().positive().optional(),
+  stop: z2.union([z2.string(), z2.array(z2.string())]).optional(),
+  tools: z2.array(
+    z2.object({
+      type: z2.literal("function"),
+      function: z2.object({
+        name: z2.string(),
+        description: z2.string().optional(),
+        parameters: z2.record(z2.string(), z2.unknown()).optional()
       })
     })
   ).optional(),
-  tool_choice: z.union([
-    z.enum(["auto", "none", "required"]),
-    z.object({ type: z.literal("function"), function: z.object({ name: z.string() }) })
+  tool_choice: z2.union([
+    z2.enum(["auto", "none", "required"]),
+    z2.object({ type: z2.literal("function"), function: z2.object({ name: z2.string() }) })
   ]).optional(),
-  user: z.string().optional()
+  user: z2.string().optional()
 });
-var positiveInt = z.number().int().positive();
-var quotaLimits = z.object({
+var positiveInt = z2.number().int().positive();
+var quotaLimits = z2.object({
   tpm: positiveInt.optional(),
   rpm: positiveInt.optional(),
   tokens5h: positiveInt.optional(),
@@ -149,41 +180,41 @@ var quotaLimits = z.object({
   requestsDaily: positiveInt.optional()
 }).strict();
 var SECRET_KEY = /^(api[-_]?key|secret|client[-_]?secret|(access|refresh|session|auth|bearer)?[-_]?token|password|passwd|cookies?|authorization|credentials?)$/i;
-var accountConfig = z.record(z.string(), z.unknown()).refine((config) => !Object.keys(config).some((key) => SECRET_KEY.test(key)), {
+var accountConfig = z2.record(z2.string(), z2.unknown()).refine((config) => !Object.keys(config).some((key) => SECRET_KEY.test(key)), {
   message: 'config must not contain credentials; send them in "secret" instead'
 });
-var subscriptionDate = z.string().trim().refine(
+var subscriptionDate = z2.string().trim().refine(
   (value) => /^\d{4}-\d{2}-\d{2}(T[\d:.]+(Z|[+-]\d{2}:?\d{2})?)?$/.test(value) && !Number.isNaN(Date.parse(value)),
   { message: "expected a date (YYYY-MM-DD) or an ISO timestamp" }
 );
-var subscriptionSchema = z.object({
-  plan: z.string().trim().min(1).max(120).optional(),
+var subscriptionSchema = z2.object({
+  plan: z2.string().trim().min(1).max(120).optional(),
   paidAt: subscriptionDate.optional(),
   renewsAt: subscriptionDate.optional(),
-  price: z.object({
-    amount: z.number().min(0).max(1e6),
-    currency: z.string().trim().regex(/^[A-Za-z]{3}$/, "expected a 3-letter currency code").transform((c) => c.toUpperCase()),
-    period: z.enum(["month", "year"])
+  price: z2.object({
+    amount: z2.number().min(0).max(1e6),
+    currency: z2.string().trim().regex(/^[A-Za-z]{3}$/, "expected a 3-letter currency code").transform((c) => c.toUpperCase()),
+    period: z2.enum(["month", "year"])
   }).strict().optional(),
-  notes: z.string().trim().max(1e3).optional()
+  notes: z2.string().trim().max(1e3).optional()
 }).strict();
 var accountFields = {
-  label: z.string().trim().min(1).max(200),
-  enabled: z.boolean().optional(),
-  priority: z.number().int().min(0).max(1e6).optional(),
-  weight: z.number().min(0).max(1e3).optional(),
+  label: z2.string().trim().min(1).max(200),
+  enabled: z2.boolean().optional(),
+  priority: z2.number().int().min(0).max(1e6).optional(),
+  weight: z2.number().min(0).max(1e3).optional(),
   limits: quotaLimits.optional(),
   config: accountConfig.optional(),
   /** API key / token. Encrypted at rest and never returned. */
-  secret: z.string().min(1).max(1e5).optional()
+  secret: z2.string().min(1).max(1e5).optional()
 };
-var accountCreateSchema = z.object({ provider: providerKind, ...accountFields, subscription: subscriptionSchema.optional() }).strict();
-var accountPatchSchema = z.object({
+var accountCreateSchema = z2.object({ provider: providerKind, ...accountFields, subscription: subscriptionSchema.optional() }).strict();
+var accountPatchSchema = z2.object({
   ...accountFields,
   label: accountFields.label.optional(),
   subscription: subscriptionSchema.nullable().optional()
 }).strict();
-var routesUpdateSchema = z.object({ routes: z.array(routeSchema).max(200), defaultRoute: z.string().min(1).optional() }).strict().superRefine((body, ctx) => {
+var routesUpdateSchema = z2.object({ routes: z2.array(routeSchema).max(200), defaultRoute: z2.string().min(1).optional() }).strict().superRefine((body, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   body.routes.forEach((route, index) => {
     if (seen.has(route.name)) {
@@ -204,14 +235,14 @@ var routesUpdateSchema = z.object({ routes: z.array(routeSchema).max(200), defau
   }
 });
 var taskText = {
-  title: z.string().trim().min(1).max(300),
-  description: z.string().max(5e4),
-  acceptance: z.array(z.string().trim().min(1).max(2e3)).max(100),
-  notes: z.string().max(5e4),
-  dependsOn: z.array(z.string().min(1)).max(500),
-  priority: z.number().finite()
+  title: z2.string().trim().min(1).max(300),
+  description: z2.string().max(5e4),
+  acceptance: z2.array(z2.string().trim().min(1).max(2e3)).max(100),
+  notes: z2.string().max(5e4),
+  dependsOn: z2.array(z2.string().min(1)).max(500),
+  priority: z2.number().finite()
 };
-var taskCreateSchema = z.object({
+var taskCreateSchema = z2.object({
   id: taskIdSchema,
   title: taskText.title,
   description: taskText.description.optional(),
@@ -219,30 +250,30 @@ var taskCreateSchema = z.object({
   priority: taskText.priority.optional(),
   acceptance: taskText.acceptance.optional()
 }).strict();
-var taskPatchSchema = z.object({
+var taskPatchSchema = z2.object({
   title: taskText.title.optional(),
   description: taskText.description.nullable().optional(),
   dependsOn: taskText.dependsOn.optional(),
   priority: taskText.priority.nullable().optional(),
   acceptance: taskText.acceptance.nullable().optional(),
   notes: taskText.notes.nullable().optional(),
-  status: z.enum(TASK_STATUSES).optional()
+  status: z2.enum(TASK_STATUSES).optional()
 }).strict().refine((patch) => Object.values(patch).some((v) => v !== void 0), {
   message: "send at least one field to change"
 });
-var runnerStartSchema = z.object({ taskId: z.string().min(1).optional() }).strict();
-var goalStartSchema = z.object({
-  objective: z.string().trim().min(1).max(4e3),
-  maxRounds: z.number().int().min(1).max(20).optional(),
-  maxTasks: z.number().int().min(1).max(100).optional(),
-  maxTokens: z.number().int().min(1e3).optional(),
-  dryRun: z.boolean().optional()
+var runnerStartSchema = z2.object({ taskId: z2.string().min(1).optional() }).strict();
+var goalStartSchema = z2.object({
+  objective: z2.string().trim().min(1).max(4e3),
+  maxRounds: z2.number().int().min(1).max(20).optional(),
+  maxTasks: z2.number().int().min(1).max(100).optional(),
+  maxTokens: z2.number().int().min(1e3).optional(),
+  dryRun: z2.boolean().optional()
 }).strict();
-var timeseriesQuerySchema = z.object({
-  minutes: z.coerce.number().int().min(1).max(7 * 24 * 60).default(60),
-  bucketSec: z.coerce.number().int().min(1).max(86400).default(60)
+var timeseriesQuerySchema = z2.object({
+  minutes: z2.coerce.number().int().min(1).max(7 * 24 * 60).default(60),
+  bucketSec: z2.coerce.number().int().min(1).max(86400).default(60)
 });
-var limitQuerySchema = (fallback, max = 1e3) => z.object({ limit: z.coerce.number().int().min(1).max(max).default(fallback) });
+var limitQuerySchema = (fallback, max = 1e3) => z2.object({ limit: z2.coerce.number().int().min(1).max(max).default(fallback) });
 function registerGoalRoutes(app, engine, options) {
   const { audit } = engine;
   const unavailable = (reply) => sendApiError(
@@ -284,7 +315,7 @@ function registerGoalRoutes(app, engine, options) {
   app.post("/api/goals", async (request, reply) => {
     const parsed = goalStartSchema.safeParse(request.body);
     if (!parsed.success) {
-      return sendApiError(reply, 400, "invalid_body", z2.prettifyError(parsed.error));
+      return sendApiError(reply, 400, "invalid_body", z3.prettifyError(parsed.error));
     }
     const goals = control(reply);
     if (!goals) return reply;
@@ -388,7 +419,7 @@ function registerTaskRoutes(app, engine, options) {
   app.post("/api/tasks", async (request, reply) => {
     const parsed = taskCreateSchema.safeParse(request.body);
     if (!parsed.success) {
-      return sendApiError(reply, 400, "invalid_body", z3.prettifyError(parsed.error));
+      return sendApiError(reply, 400, "invalid_body", z4.prettifyError(parsed.error));
     }
     const brain = writable(reply);
     if (isReply(brain)) return brain;
@@ -403,7 +434,7 @@ function registerTaskRoutes(app, engine, options) {
   app.patch("/api/tasks/:id", async (request, reply) => {
     const parsed = taskPatchSchema.safeParse(request.body);
     if (!parsed.success) {
-      return sendApiError(reply, 400, "invalid_body", z3.prettifyError(parsed.error));
+      return sendApiError(reply, 400, "invalid_body", z4.prettifyError(parsed.error));
     }
     const brain = writable(reply);
     if (isReply(brain)) return brain;
@@ -446,7 +477,7 @@ function isReply(value) {
 var EMPTY_GRAPH = { version: 1, tasks: [] };
 var IDLE = { state: "idle" };
 function invalid(reply, error) {
-  return sendApiError(reply, 400, "invalid_body", z4.prettifyError(error));
+  return sendApiError(reply, 400, "invalid_body", z5.prettifyError(error));
 }
 function registerApiRoutes(app, engine, options) {
   const { accounts, events, audit, quota, keyring } = engine;
@@ -748,7 +779,7 @@ function registerAuthRoutes(app, login) {
       reply.header("Cache-Control", "no-store").header("Referrer-Policy", "no-referrer");
       if (!login)
         return sendApiError(reply, 503, "login_not_configured", "Sign-in is not configured.");
-      const parsed = z5.object({ state: z5.string().min(1).max(200), code: z5.string().min(1).max(4096) }).safeParse(request.query);
+      const parsed = z6.object({ state: z6.string().min(1).max(200), code: z6.string().min(1).max(4096) }).safeParse(request.query);
       const binding = authCookie(request, "dc_login");
       if (!parsed.success || !binding)
         return reply.redirect(`${login.options.origin}/#/login?error=signin_failed`);
@@ -848,7 +879,7 @@ function registerV1Routes(app, engine) {
     const parsed = chatRequestSchema.safeParse(request.body);
     if (!parsed.success) {
       return sendOpenAIError(reply, 400, {
-        message: z6.prettifyError(parsed.error),
+        message: z7.prettifyError(parsed.error),
         type: "invalid_request_error",
         code: "invalid_body"
       });
@@ -1095,6 +1126,7 @@ async function buildGateway(engine, options = {}) {
   });
   registerV1Routes(app, engine);
   registerAuthRoutes(app, login);
+  registerAccountRoutes(app, options.account);
   registerApiRoutes(app, engine, options);
   registerEventRoutes(app, engine, options.heartbeatMs ?? 15e3);
   return app;
@@ -1633,18 +1665,25 @@ async function startRuntime(options) {
     ...projectRoot ? { projectRoot } : {},
     ...options.config ? { config: options.config } : {}
   });
+  let account;
   try {
     const project = projectRoot ? wireProject(engine, projectRoot, { env: options.env }) : void 0;
     const wantDashboard = options.dashboard !== false && engine.config.server.dashboard;
     const dashboardDir = wantDashboard ? resolveDashboardDir(options.env) : void 0;
     const bindHost = options.host ?? engine.config.server.host;
     const loginLauncher = LOOPBACK_HOSTS.has(bindHost) ? {
-      launch: async (account) => ({
-        launched: await launchLoginTerminal(account.id, { env: options.env })
+      launch: async (account2) => ({
+        launched: await launchLoginTerminal(account2.id, { env: options.env })
       })
     } : void 0;
+    account = LOOPBACK_HOSTS.has(bindHost) ? createAccountControl({
+      home: options.home,
+      env: options.env,
+      open: (url) => openBrowser(url)
+    }) : void 0;
     const app = await startGateway(engine, {
       logger: options.logger ?? false,
+      ...account ? { account } : {},
       ...options.loginLauncher ?? loginLauncher ? { loginLauncher: options.loginLauncher ?? loginLauncher } : {},
       ...dashboardDir ? { dashboardDir } : {},
       ...project ? { brain: project.source, runner: project.runner, goals: project.goals } : {},
@@ -1674,6 +1713,7 @@ async function startRuntime(options) {
           const active = goals?.activeGoalId;
           if (active) await goals?.cancel(active);
           await runner?.stop();
+          await account?.close();
           await app.close();
         } finally {
           engine.close();
@@ -1681,6 +1721,7 @@ async function startRuntime(options) {
       }
     };
   } catch (err) {
+    await account?.close();
     engine.close();
     throw err;
   }
@@ -1703,4 +1744,4 @@ export {
   resolveProjectRoot,
   startRuntime
 };
-//# sourceMappingURL=chunk-JFWMLYV7.js.map
+//# sourceMappingURL=chunk-YSD6W27K.js.map