@jagit/shared 0.0.1 → 0.0.2

package/dist/config.d.ts

@@ -8,6 +8,8 @@ export declare function parseConfig(env: RawEnv): {
     approvalTimeoutMs: number;
     acpRequestTimeoutMs: number;
     anthropicApiKey: string;
+    anthropicAuthToken: string;
+    anthropicBaseUrl: string | undefined;
     telegramBotToken: string;
     publicBaseUrl: string;
     apiPort: number;

package/dist/config.js

@@ -7,15 +7,20 @@ const Schema = z.object({
     MAX_RETRIES: z.coerce.number().int().nonnegative(),
     APPROVAL_TIMEOUT_MS: z.coerce.number().int().positive(),
     ACP_REQUEST_TIMEOUT_MS: z.coerce.number().int().positive().default(600_000),
-    ANTHROPIC_API_KEY: z.string().min(1),
+    ANTHROPIC_API_KEY: z.string().min(1).optional(),
+    ANTHROPIC_AUTH_TOKEN: z.string().min(1).optional(),
+    ANTHROPIC_BASE_URL: z.string().url().optional(),
     TELEGRAM_BOT_TOKEN: z.string().min(1),
     PUBLIC_BASE_URL: z.string().url(),
     API_PORT: z.coerce.number().int().positive().default(3000),
     API_WEBHOOK_SECRET: z.string().min(1),
     DASHBOARD_API_TOKEN: z.string().min(1),
+}).refine((data) => !!(data.ANTHROPIC_AUTH_TOKEN || data.ANTHROPIC_API_KEY), {
+    message: "Either ANTHROPIC_AUTH_TOKEN or ANTHROPIC_API_KEY must be provided",
 });
 export function parseConfig(env) {
     const p = Schema.parse(env);
+    const anthropicAuthToken = p.ANTHROPIC_AUTH_TOKEN || p.ANTHROPIC_API_KEY || "";
     return {
         databaseUrl: p.DATABASE_URL,
         redisUrl: p.REDIS_URL,
@@ -24,7 +29,9 @@ export function parseConfig(env) {
         maxRetries: p.MAX_RETRIES,
         approvalTimeoutMs: p.APPROVAL_TIMEOUT_MS,
         acpRequestTimeoutMs: p.ACP_REQUEST_TIMEOUT_MS,
-        anthropicApiKey: p.ANTHROPIC_API_KEY,
+        anthropicApiKey: anthropicAuthToken,
+        anthropicAuthToken,
+        anthropicBaseUrl: p.ANTHROPIC_BASE_URL,
         telegramBotToken: p.TELEGRAM_BOT_TOKEN,
         publicBaseUrl: p.PUBLIC_BASE_URL,
         apiPort: p.API_PORT,

package/dist/credentials.d.ts

@@ -29,7 +29,8 @@ export declare const AnthropicCredentialSchema: z.ZodObject<{
         baseUrl: z.ZodOptional<z.ZodString>;
     }, z.core.$catchall<z.ZodString>>>>;
     secrets: z.ZodObject<{
-        apiKey: z.ZodString;
+        apiKey: z.ZodOptional<z.ZodString>;
+        authToken: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const TelegramCredentialSchema: z.ZodObject<{
@@ -61,7 +62,8 @@ export declare function validateCredential(kind: CredentialKind, input: unknown)
         baseUrl?: string | undefined;
     };
     secrets: {
-        apiKey: string;
+        apiKey?: string | undefined;
+        authToken?: string | undefined;
     };
 } | {
     meta: {

package/dist/credentials.js

@@ -32,8 +32,9 @@ export const AnthropicCredentialSchema = z.object({
         .optional()
         .default({}),
     secrets: z.object({
-        apiKey: z.string().min(1),
-    }),
+        apiKey: z.string().min(1).optional(),
+        authToken: z.string().min(1).optional(),
+    }).refine((s) => !!(s.apiKey || s.authToken), { message: "Either apiKey or authToken is required" }),
 });
 export const TelegramCredentialSchema = z.object({
     meta: z
@@ -55,7 +56,7 @@ export function credentialSecretKeys(kind) {
         case "gitlab":
             return ["token"];
         case "anthropic":
-            return ["apiKey"];
+            return ["authToken", "apiKey"];
         case "telegram":
             return ["botToken"];
     }

package/dist/events.js

@@ -6,7 +6,11 @@ export const controlChannel = (jobId) => `control:${jobId}`;
 /** Channel name for global approval events (SSE + worker graph) */
 export const approvalsChannel = "approvals";
 export function makeRedis(url) {
-    return new Redis(url, { maxRetriesPerRequest: null, lazyConnect: false });
+    const client = new Redis(url, { maxRetriesPerRequest: null, lazyConnect: false });
+    client.on("error", (err) => {
+        console.error("Redis client error:", err.message);
+    });
+    return client;
 }
 /** Publish any JSON-serialisable payload to a channel */
 export async function publishEvent(url, channel, data) {

package/dist/index.d.ts

@@ -13,3 +13,4 @@ export * from "./seed.js";
 export * from "./mcp-config.js";
 export * from "./mcp-servers.js";
 export * from "./approval-bridge.js";
+export * from "./jira-worklog.js";

package/dist/index.js

@@ -12,3 +12,4 @@ export * from "./seed.js";
 export * from "./mcp-config.js";
 export * from "./mcp-servers.js";
 export * from "./approval-bridge.js";
+export * from "./jira-worklog.js";

package/dist/jira-worklog.d.ts

@@ -0,0 +1,11 @@
+export interface CreateWorklogOpts {
+    ticketId: string;
+    durationMs: number;
+    baseTokens: number;
+    comment?: string;
+}
+export interface CreateWorklogResult {
+    success: boolean;
+    reason?: string;
+}
+export declare function createJiraWorklog(opts: CreateWorklogOpts): Promise<CreateWorklogResult>;

package/dist/jira-worklog.js

@@ -0,0 +1,88 @@
+import { prisma } from "./prisma.js";
+import { withRetry } from "./retry.js";
+import { decrypt } from "./crypto.js";
+import { loadConfig } from "./config.js";
+function formatJiraApiError(status, detail) {
+    return `Jira API error: ${status} ${detail}`;
+}
+function formatDuration(ms) {
+    const totalMinutes = Math.floor(ms / 60000);
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    if (hours > 0 && minutes > 0) {
+        return `${hours}h ${minutes}m`;
+    }
+    else if (hours > 0) {
+        return `${hours}h`;
+    }
+    else {
+        return `${minutes}m`;
+    }
+}
+function formatBT(bt) {
+    return bt.toLocaleString("en-US");
+}
+// Jira's worklog API rejects timeSpentSeconds values that round to 0 minutes under the
+// project's time-tracking format with "Worklog must not be null" / "must indicate time spent".
+const MIN_JIRA_WORKLOG_SECONDS = 60;
+export async function createJiraWorklog(opts) {
+    try {
+        const credential = await prisma.credential.findUnique({
+            where: { kind_name: { kind: "jira", name: "default" } },
+        });
+        if (!credential) {
+            console.error("[jira-worklog] No Jira credentials found, skipping worklog");
+            return { success: false, reason: "No Jira credentials found" };
+        }
+        const meta = credential.meta;
+        const encrypted = credential.secrets.encrypted;
+        if (!encrypted || !meta.baseUrl) {
+            console.error("[jira-worklog] Incomplete Jira credentials, skipping worklog");
+            return { success: false, reason: "Incomplete Jira credentials" };
+        }
+        const { encryptionKey } = loadConfig();
+        const secrets = JSON.parse(decrypt(encrypted, encryptionKey));
+        if (!secrets.email || !secrets.token) {
+            console.error("[jira-worklog] Incomplete Jira credentials, skipping worklog");
+            return { success: false, reason: "Incomplete Jira credentials" };
+        }
+        // Jira Cloud API tokens authenticate via HTTP Basic auth (email:token), not Bearer —
+        // Bearer is reserved for OAuth/Connect-app sessions and Jira rejects it with
+        // "Failed to parse Connect Session Auth Token".
+        const basicAuth = Buffer.from(`${secrets.email}:${secrets.token}`).toString("base64");
+        const timeSpentSeconds = Math.max(Math.floor(opts.durationMs / 1000), MIN_JIRA_WORKLOG_SECONDS);
+        const durationStr = formatDuration(opts.durationMs);
+        const btStr = formatBT(opts.baseTokens);
+        const defaultComment = `AI Logwork for ${opts.ticketId}\nTime Spent: ${durationStr}\nToken Spent: ${btStr} BT`;
+        const url = `${meta.baseUrl.replace(/\/+$/, "")}/rest/api/2/issue/${opts.ticketId}/worklog`;
+        return await withRetry(async () => {
+            const res = await fetch(url, {
+                method: "POST",
+                headers: {
+                    Authorization: `Basic ${basicAuth}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    timeSpentSeconds,
+                    comment: opts.comment ?? defaultComment,
+                }),
+            });
+            if (!res.ok) {
+                const detail = await res.text().catch(() => "");
+                if (res.status >= 500) {
+                    throw new Error(formatJiraApiError(res.status, detail));
+                }
+                const reason = formatJiraApiError(res.status, detail);
+                console.error(`[jira-worklog] Non-retryable error ${res.status}: ${detail}`);
+                return { success: false, reason };
+            }
+            console.log(`[jira-worklog] Created worklog for ${opts.ticketId}`);
+            return { success: true };
+        }, { maxRetries: 3, baseDelayMs: 1000 });
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        console.error("[jira-worklog] Failed to create worklog:", reason);
+        return { success: false, reason };
+    }
+}

package/dist/queue.js

@@ -2,6 +2,18 @@ import { Queue, Worker } from "bullmq";
 import { JOB_QUEUE } from "./types.js";
 const connection = (url) => ({ connection: { url } });
 /** Creates the BullMQ queue used by the API to enqueue jobs */
-export const createQueue = (redisUrl) => new Queue(JOB_QUEUE, connection(redisUrl));
+export const createQueue = (redisUrl) => {
+    const queue = new Queue(JOB_QUEUE, connection(redisUrl));
+    queue.on("error", (err) => {
+        console.error("BullMQ Queue error:", err.message);
+    });
+    return queue;
+};
 /** Creates the BullMQ worker consumed by the worker service */
-export const createWorker = (redisUrl, processor, concurrency) => new Worker(JOB_QUEUE, processor, { ...connection(redisUrl), concurrency });
+export const createWorker = (redisUrl, processor, concurrency) => {
+    const worker = new Worker(JOB_QUEUE, processor, { ...connection(redisUrl), concurrency });
+    worker.on("error", (err) => {
+        console.error("BullMQ Worker error:", err.message);
+    });
+    return worker;
+};

package/dist/seed.d.ts

@@ -93,7 +93,8 @@ export interface SeedPrismaClient {
     };
 }
 export declare function buildSeedData(input: {
-    anthropicApiKey: string;
+    anthropicAuthToken: string;
+    anthropicBaseUrl?: string;
 }): SeedData;
 export declare function seedDatabase(client: SeedPrismaClient, seedData: SeedData, encryptionKey: string): Promise<void>;
 export {};

package/dist/seed.js

@@ -60,8 +60,8 @@ export function buildSeedData(input) {
             {
                 kind: "anthropic",
                 name: "default",
-                secrets: { apiKey: input.anthropicApiKey },
-                meta: {},
+                secrets: { authToken: input.anthropicAuthToken },
+                meta: input.anthropicBaseUrl ? { baseUrl: input.anthropicBaseUrl } : {},
             },
         ],
         repoMapping: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jagit/shared",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/prisma/migrations/20260621082352_add_cache_creation_input_tokens/migration.sql

@@ -0,0 +1,22 @@
+-- AlterTable
+ALTER TABLE "AgentSession" ADD COLUMN     "cacheCreationInputTokens" INTEGER NOT NULL DEFAULT 0;
+
+-- CreateTable
+CREATE TABLE "ModelPricing" (
+    "id" TEXT NOT NULL,
+    "model" TEXT NOT NULL,
+    "inputCostPerToken" DOUBLE PRECISION NOT NULL DEFAULT 0,
+    "outputCostPerToken" DOUBLE PRECISION NOT NULL DEFAULT 0,
+    "cacheCreationInputTokenCost" DOUBLE PRECISION,
+    "cacheReadInputTokenCost" DOUBLE PRECISION,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "ModelPricing_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "ModelPricing_model_key" ON "ModelPricing"("model");
+
+-- CreateIndex
+CREATE INDEX "ModelPricing_model_idx" ON "ModelPricing"("model");

package/prisma/migrations/20260621120000_add_session_tracking_fields/migration.sql

@@ -0,0 +1,9 @@
+-- AlterTable
+ALTER TABLE "AgentSession" ADD COLUMN     "durationMs" INTEGER,
+ADD COLUMN     "initialCommitSha" TEXT,
+ADD COLUMN     "jiraTicketId" TEXT,
+ADD COLUMN     "linesAdded" INTEGER,
+ADD COLUMN     "linesRemoved" INTEGER;
+
+-- CreateIndex
+CREATE INDEX "AgentSession_jiraTicketId_idx" ON "AgentSession"("jiraTicketId");

package/prisma/migrations/migration_lock.toml

@@ -1,3 +1,3 @@
 # Please do not edit this file manually
-# It should be added in your version-control system (i.e. Git)
+# It should be added in your version-control system (e.g., Git)
 provider = "postgresql"

package/prisma/schema.prisma

@@ -4,6 +4,7 @@ generator client {
 
 datasource db {
   provider = "postgresql"
+  
 }
 
 // ─── Enums ───────────────────────────────────────────────────────────────────
@@ -235,23 +236,52 @@ enum AgentTool {
 }
 
 model AgentSession {
-  id                String    @id @default(cuid())
-  tool              AgentTool
-  sessionId         String
-  userId            String
-  user              User      @relation(fields: [userId], references: [id], onDelete: Cascade)
-  model             String
-  inputTokens       Int       @default(0)
-  cachedInputTokens Int       @default(0)
-  outputTokens      Int       @default(0)
-  costUsd           Float?
-  toolCallCount     Int?
-  startedAt         DateTime
-  lastUpdatedAt     DateTime  @updatedAt
-  rawPayload        Json      @default("{}")
-  createdAt         DateTime  @default(now())
+  id                       String    @id @default(cuid())
+  tool                     AgentTool
+  sessionId                String
+  userId                   String
+  user                     User      @relation(fields: [userId], references: [id], onDelete: Cascade)
+  model                    String
+  inputTokens              Int       @default(0)
+  cachedInputTokens        Int       @default(0)
+  cacheCreationInputTokens Int       @default(0)
+  outputTokens             Int       @default(0)
+  costUsd                  Float?
+  toolCallCount            Int?
+  startedAt                DateTime
+  lastUpdatedAt            DateTime  @updatedAt
+  rawPayload               Json      @default("{}")
+  createdAt                DateTime  @default(now())
+
+  // Jira association
+  jiraTicketId             String?
+
+  // Time tracking
+  initialCommitSha         String?
+  durationMs               Int?
+
+  // Lines of code
+  linesAdded               Int?
+  linesRemoved             Int?
 
   @@unique([tool, sessionId])
   @@index([userId, lastUpdatedAt])
   @@index([tool, lastUpdatedAt])
+  @@index([jiraTicketId])
+}
+
+// ─── ModelPricing ────────────────────────────────────────────────────────────
+// Periodically updated model API pricing.
+
+model ModelPricing {
+  id                          String   @id @default(cuid())
+  model                       String   @unique
+  inputCostPerToken           Float    @default(0)
+  outputCostPerToken          Float    @default(0)
+  cacheCreationInputTokenCost Float?
+  cacheReadInputTokenCost     Float?
+  createdAt                   DateTime @default(now())
+  updatedAt                   DateTime @updatedAt
+
+  @@index([model])
 }