kalvium-worklog 1.0.0

package/README.md

@@ -0,0 +1,124 @@
+# kalvium-worklog
+
+Auto-submit your daily [Kalvium](https://kalvium.community) worklog without opening the website.
+
+## Install
+
+```bash
+npm install -g kalvium-worklog
+```
+
+## Quick Start
+
+```bash
+# Full setup (login + discover position + schedule + phone webapp)
+kalvium-worklog install
+
+# Or step by step:
+kalvium-worklog login       # log in via browser (Google + 2FA)
+kalvium-worklog discover    # auto-discover your position ID
+kalvium-worklog schedule 14:00  # daily auto-submit at 2 PM
+kalvium-worklog webapp      # generate phone web app
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `kalvium-worklog install` | Full setup: login + discover + schedule + webapp |
+| `kalvium-worklog login` | Log in to Kalvium (opens browser, waits for Google + 2FA) |
+| `kalvium-worklog discover` | Auto-discover your internship position ID |
+| `kalvium-worklog submit [text]` | Submit worklog (default: "working") |
+| `kalvium-worklog submit "built a feature"` | Submit with custom text |
+| `kalvium-worklog submit --status remote` | Submit with custom status |
+| `kalvium-worklog submit --dry-run` | Test without submitting |
+| `kalvium-worklog status` | Check recent worklog entries |
+| `kalvium-worklog schedule 14:00` | Set up daily auto-submit at 2 PM |
+| `kalvium-worklog schedule --remove` | Remove daily auto-submit |
+| `kalvium-worklog webapp [path]` | Generate phone web app HTML |
+| `kalvium-worklog daily` | Run daily submit (used by scheduler) |
+
+## Features
+
+- **Cross-platform**: macOS (launchd), Windows (Task Scheduler), Linux (cron)
+- **Auto re-login**: If the token expires, automatically opens browser, waits for login, and retries
+- **Token auto-refresh**: Refresh token rotates on each use, lasts 6 days
+- **Phone web app**: Submit from your iPhone/Android (no computer needed after setup)
+- **Auto-discovers position ID**: Works for any user, no hardcoded IDs
+- **Weekend skipping**: Auto-submit skips Saturdays and Sundays
+
+## Work Statuses
+
+| Key | Label |
+|-----|-------|
+| `on_site` | Working on-site (Company location) |
+| `remote` | Working Remotely (Not in the Kalvium environment) |
+| `classroom` | Working out of the Kalvium environment (Classroom) |
+| `holiday` | Today was a company Holiday |
+| `leave` | Took an approved leave from work |
+
+```bash
+kalvium-worklog submit "worked from home" --status remote
+```
+
+## Phone Web App
+
+After running `kalvium-worklog webapp`:
+
+1. AirDrop `~/KalviumWorklog.html` to your phone
+2. Open in **Safari** (iPhone) or **Chrome** (Android)
+3. **Add to Home Screen**
+4. Tap the icon to submit worklogs from your phone
+
+The phone app works independently — it refreshes its own token and auto-retries if the token expires.
+
+## How It Works
+
+```
+One-time setup:
+  Browser login → capture refresh token → discover position ID
+
+Daily auto-submit (scheduler):
+  Refresh token → PUT worklog API → done
+  If token expired → auto open browser → re-login → retry
+
+Manual submit:
+  kalvium-worklog submit "my update" → refresh token → PUT worklog
+```
+
+## Token Lifecycle
+
+- **Access token**: 3 days
+- **Refresh token**: 6 days, rotates on each use
+- As long as you submit at least once every 6 days, the token never expires
+- If expired: `kalvium-worklog login` (or it auto-triggers)
+
+## Files
+
+```
+~/.kalvium/
+├── refresh_token.json    # Current token (auto-rotates)
+├── config.json           # Position ID + API URL
+├── daily_submit.js       # Scheduler entry point
+└── worklog.log           # Log file
+
+~/.kalvium_profile/       # Browser profile (saved login)
+~/KalviumWorklog.html     # Phone web app
+```
+
+## Uninstall
+
+```bash
+kalvium-worklog schedule --remove
+npm uninstall -g kalvium-worklog
+rm -rf ~/.kalvium ~/.kalvium_profile ~/KalviumWorklog.html
+```
+
+## Requirements
+
+- Node.js 18+
+- npm
+
+## License
+
+MIT

package/dist/capture-token.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Try headless mode first (fast — works if session is still valid).
+ * If no session, opens a headed browser and waits for manual login.
+ */
+export declare function captureToken(): Promise<boolean>;

package/dist/capture-token.js

@@ -0,0 +1,128 @@
+import { chromium } from "playwright";
+import { PROFILE_DIR, TOKEN_FILE, ensureInstallDir, saveToken, } from "./config.js";
+/**
+ * Try headless mode first (fast — works if session is still valid).
+ * If no session, opens a headed browser and waits for manual login.
+ */
+export async function captureToken() {
+    ensureInstallDir();
+    // Step 1: Try headless (quick — works if session is still valid)
+    console.log("Trying headless mode (existing session)...");
+    let data = await tryCapture(true);
+    if (data) {
+        console.log("  Session still valid — token captured!");
+    }
+    else {
+        // Step 2: Need manual login
+        console.log("  No valid session. Opening browser for manual login...");
+        data = await tryCapture(false);
+    }
+    if (data) {
+        saveToken(data);
+        console.log(`\nToken saved to ${TOKEN_FILE}`);
+        console.log(`  Access token expires in: ${data.expires_in ?? "?"} seconds`);
+        console.log(`  Refresh token expires in: ${data.refresh_expires_in ?? "?"} seconds`);
+        return true;
+    }
+    console.log("\nERROR: Could not capture token. Please log in and try again.");
+    return false;
+}
+async function tryCapture(headless) {
+    const tokenData = {};
+    const context = await chromium.launchPersistentContext(PROFILE_DIR, {
+        headless: false, // Playwright doesn't support --headless=new directly
+        args: [
+            "--disable-blink-features=AutomationControlled",
+            ...(headless ? ["--headless=new"] : []),
+        ],
+    });
+    const page = context.pages()[0] ?? (await context.newPage());
+    // Intercept token exchange requests
+    context.route("**/openid-connect/token", (route) => {
+        if (route.request().method() === "POST") {
+            route.fetch().then((response) => {
+                response
+                    .text()
+                    .then((text) => {
+                    try {
+                        const data = JSON.parse(text);
+                        if (data.refresh_token) {
+                            if (!headless)
+                                console.log("  Refresh token captured!");
+                            tokenData.data = data;
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
+                })
+                    .catch(() => { });
+                route.fulfill({ response }).catch(() => { });
+            });
+        }
+        else {
+            route.continue().catch(() => { });
+        }
+    });
+    if (headless) {
+        console.log("Loading kalvium.community/internships (headless)...");
+        try {
+            await page.goto("https://kalvium.community/internships", {
+                waitUntil: "domcontentloaded",
+                timeout: 30000,
+            });
+            await page
+                .waitForLoadState("networkidle", { timeout: 20000 })
+                .catch(() => { });
+            await page.waitForTimeout(8000);
+        }
+        catch {
+            // ignore
+        }
+    }
+    else {
+        console.log("\n  ========================================");
+        console.log("  Browser opened. Please log in now:");
+        console.log("  1. Click 'Continue with Google'");
+        console.log("  2. Sign in with your Kalvium account");
+        console.log("  3. Complete 2FA if prompted");
+        console.log("  4. Wait — the script continues automatically");
+        console.log("  ========================================\n");
+        await page.goto("https://kalvium.community/internships", {
+            waitUntil: "domcontentloaded",
+            timeout: 120000,
+        });
+        console.log("  Waiting for login to complete (up to 5 minutes)...");
+        // Poll up to 5 minutes
+        for (let i = 0; i < 300; i++) {
+            if (tokenData.data)
+                break;
+            await page.waitForTimeout(1000);
+            if (i > 0 && i % 30 === 0) {
+                const url = page.url();
+                if (url.includes("kalvium.community/internships") &&
+                    !url.includes("error")) {
+                    await page
+                        .waitForLoadState("networkidle", { timeout: 5000 })
+                        .catch(() => { });
+                }
+            }
+        }
+        // Last resort: reload to trigger token exchange
+        if (!tokenData.data) {
+            console.log("  Trying page reload to trigger token exchange...");
+            try {
+                await page.reload({ waitUntil: "domcontentloaded", timeout: 30000 });
+                await page
+                    .waitForLoadState("networkidle", { timeout: 15000 })
+                    .catch(() => { });
+                await page.waitForTimeout(8000);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    await context.close();
+    return tokenData.data ?? null;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { captureToken } from "./capture-token.js";
+import { discoverPosition } from "./discover-position.js";
+import { submitWorklog, checkStatus, dailySubmit } from "./submit.js";
+import { setupScheduler, removeScheduler } from "./scheduler.js";
+import { generateWebapp } from "./generate-webapp.js";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const program = new Command();
+program
+    .name("kalvium-worklog")
+    .description("Auto-submit your daily Kalvium worklog")
+    .version("1.0.0");
+// ─── login ─────────────────────────────────────────────────────────────────
+program
+    .command("login")
+    .description("Log in to Kalvium and capture refresh token (opens browser)")
+    .action(async () => {
+    const ok = await captureToken();
+    if (!ok)
+        process.exit(1);
+});
+// ─── discover ──────────────────────────────────────────────────────────────
+program
+    .command("discover")
+    .description("Auto-discover your internship position ID")
+    .action(async () => {
+    const ok = await discoverPosition();
+    if (!ok)
+        process.exit(1);
+});
+// ─── submit ────────────────────────────────────────────────────────────────
+program
+    .command("submit [text]")
+    .description("Submit worklog (default text: 'working')")
+    .option("--status <type>", "Work status", "on_site")
+    .option("--dry-run", "Test without submitting")
+    .action(async (text, opts) => {
+    // Skip weekends (unless dry run)
+    const day = new Date().getDay();
+    if ((day === 0 || day === 6) && !opts.dryRun) {
+        console.log("It's a weekend — skipping.");
+        return;
+    }
+    const result = await submitWorklog({
+        text: text ?? "working",
+        status: opts.status,
+        dryRun: opts.dryRun,
+    });
+    if (!result.success)
+        process.exit(1);
+});
+// ─── status ────────────────────────────────────────────────────────────────
+program
+    .command("status")
+    .description("Check recent worklog entries")
+    .action(async () => {
+    await checkStatus();
+});
+// ─── daily ─────────────────────────────────────────────────────────────────
+program
+    .command("daily")
+    .description("Run daily auto-submit (used by scheduler — skips weekends)")
+    .action(async () => {
+    const ok = await dailySubmit();
+    if (!ok)
+        process.exit(1);
+});
+// ─── schedule ──────────────────────────────────────────────────────────────
+program
+    .command("schedule [time]")
+    .description("Set up daily auto-submit (e.g. '14:00' for 2 PM)")
+    .option("--remove", "Remove the scheduled task")
+    .action(async (time, opts) => {
+    if (opts.remove) {
+        await removeScheduler();
+        return;
+    }
+    let hour = 14;
+    let minute = 0;
+    if (time) {
+        const match = time.match(/^(\d{1,2}):(\d{2})$/);
+        if (!match) {
+            console.log("Invalid time format. Use HH:MM (e.g. 14:00 for 2 PM)");
+            process.exit(1);
+        }
+        hour = parseInt(match[1], 10);
+        minute = parseInt(match[2], 10);
+        if (hour < 0 || hour > 23 || minute < 0 || minute > 59) {
+            console.log("Invalid time. Hour: 0-23, Minute: 0-59");
+            process.exit(1);
+        }
+    }
+    else {
+        // Interactive prompt
+        const readline = await import("readline");
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+        const hourInput = await ask("Enter hour (24-hour, e.g. 14 for 2 PM) [14]: ");
+        const minuteInput = await ask("Enter minute [0]: ");
+        rl.close();
+        hour = parseInt(hourInput || "14", 10);
+        minute = parseInt(minuteInput || "0", 10);
+        if (isNaN(hour) || hour < 0 || hour > 23) {
+            console.log("Invalid hour, defaulting to 14 (2 PM)");
+            hour = 14;
+        }
+        if (isNaN(minute) || minute < 0 || minute > 59) {
+            console.log("Invalid minute, defaulting to 0");
+            minute = 0;
+        }
+    }
+    const ok = await setupScheduler({ hour, minute });
+    if (!ok)
+        process.exit(1);
+});
+// ─── webapp ────────────────────────────────────────────────────────────────
+program
+    .command("webapp [path]")
+    .description("Generate phone web app HTML (default: ~/KalviumWorklog.html)")
+    .action(async (path) => {
+    const ok = await generateWebapp(path);
+    if (!ok)
+        process.exit(1);
+});
+// ─── install (full setup) ──────────────────────────────────────────────────
+program
+    .command("install")
+    .description("Full setup: login + discover + schedule + webapp")
+    .action(async () => {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    console.log("\n🚀 Kalvium Worklog — Full Setup\n");
+    // Step 1: Login
+    console.log("── Step 1: Log in ──");
+    console.log("A browser will open. Log in with Google + 2FA if needed.\n");
+    const loginOk = await captureToken();
+    if (!loginOk) {
+        console.log("Login failed. Try again with `kalvium-worklog login`");
+        rl.close();
+        process.exit(1);
+    }
+    // Step 2: Discover position
+    console.log("\n── Step 2: Discover position ID ──");
+    const discoverOk = await discoverPosition();
+    if (!discoverOk) {
+        console.log("Discovery failed. Try again with `kalvium-worklog discover`");
+        rl.close();
+        process.exit(1);
+    }
+    // Step 3: Schedule
+    console.log("\n── Step 3: Set up daily auto-submit ──");
+    const timeInput = await ask("What time? (HH:MM, e.g. 14:00 for 2 PM) [14:00]: ");
+    rl.close();
+    let hour = 14;
+    let minute = 0;
+    if (timeInput.trim()) {
+        const match = timeInput.trim().match(/^(\d{1,2}):(\d{2})$/);
+        if (match) {
+            hour = parseInt(match[1], 10);
+            minute = parseInt(match[2], 10);
+        }
+    }
+    await setupScheduler({ hour, minute });
+    // Step 4: Webapp
+    console.log("\n── Step 4: Generate phone web app ──");
+    await generateWebapp();
+    console.log("\n✅ Setup complete!\n");
+    console.log("Commands:");
+    console.log("  kalvium-worklog submit              # submit with 'working'");
+    console.log("  kalvium-worklog submit 'my update'  # custom text");
+    console.log("  kalvium-worklog status              # check status");
+    console.log("  kalvium-worklog schedule --remove   # stop automation");
+    console.log("");
+});
+// ─── Default: show help ────────────────────────────────────────────────────
+if (process.argv.length <= 2) {
+    // Check if already set up
+    const tokenExists = existsSync(join(homedir(), ".kalvium", "refresh_token.json"));
+    const configExists = existsSync(join(homedir(), ".kalvium", "config.json"));
+    if (!tokenExists || !configExists) {
+        console.log("");
+        console.log("  Welcome to Kalvium Worklog!");
+        console.log("");
+        console.log("  You haven't set up yet. Run:");
+        console.log("");
+        console.log("    kalvium-worklog install");
+        console.log("");
+        console.log("  This will log you in, discover your position ID,");
+        console.log("  set up daily auto-submit, and generate a phone web app.");
+        console.log("");
+        console.log("  Or run kalvium-worklog --help to see all commands.");
+        console.log("");
+    }
+    else {
+        program.help();
+    }
+    process.exit(0);
+}
+program.parse();

package/dist/config.d.ts

@@ -0,0 +1,29 @@
+export declare const INSTALL_DIR: string;
+export declare const PROFILE_DIR: string;
+export declare const TOKEN_FILE: string;
+export declare const CONFIG_FILE: string;
+export declare const LOG_FILE: string;
+export declare const KEYCLOAK_URL = "https://auth.kalvium.community/auth/realms/kalvium/protocol/openid-connect/token";
+export declare const CLIENT_ID = "login_client";
+export declare const API_BASE = "https://student-api.kalvium.community/api/internships/worklogs";
+export interface TokenData {
+    access_token: string;
+    refresh_token: string;
+    expires_in?: number;
+    refresh_expires_in?: number;
+    token_type?: string;
+    session_state?: string;
+}
+export interface ConfigData {
+    position_id: string;
+    worklog_api_url: string;
+}
+export declare function ensureInstallDir(): void;
+export declare function loadToken(): TokenData | null;
+export declare function saveToken(data: TokenData): void;
+export declare function loadConfig(): ConfigData | null;
+export declare function saveConfig(config: ConfigData): void;
+export declare function getWorklogApi(): string | null;
+export declare function log(message: string): void;
+export declare function decodeJwt(token: string): Record<string, unknown> | null;
+export declare function getPositionIdFromToken(token: TokenData): string | null;

package/dist/config.js

@@ -0,0 +1,75 @@
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+export const INSTALL_DIR = join(homedir(), ".kalvium");
+export const PROFILE_DIR = join(homedir(), ".kalvium_profile");
+export const TOKEN_FILE = join(INSTALL_DIR, "refresh_token.json");
+export const CONFIG_FILE = join(INSTALL_DIR, "config.json");
+export const LOG_FILE = join(INSTALL_DIR, "worklog.log");
+export const KEYCLOAK_URL = "https://auth.kalvium.community/auth/realms/kalvium/protocol/openid-connect/token";
+export const CLIENT_ID = "login_client";
+export const API_BASE = "https://student-api.kalvium.community/api/internships/worklogs";
+export function ensureInstallDir() {
+    if (!existsSync(INSTALL_DIR)) {
+        mkdirSync(INSTALL_DIR, { recursive: true });
+    }
+}
+export function loadToken() {
+    if (!existsSync(TOKEN_FILE))
+        return null;
+    try {
+        return JSON.parse(readFileSync(TOKEN_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveToken(data) {
+    ensureInstallDir();
+    writeFileSync(TOKEN_FILE, JSON.stringify(data, null, 2));
+}
+export function loadConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return null;
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(config) {
+    ensureInstallDir();
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export function getWorklogApi() {
+    const config = loadConfig();
+    return config?.worklog_api_url ?? null;
+}
+export function log(message) {
+    ensureInstallDir();
+    const timestamp = new Date().toISOString().replace("T", " ").slice(0, 19);
+    const line = `${timestamp} ${message}\n`;
+    try {
+        writeFileSync(LOG_FILE, line, { flag: "a" });
+    }
+    catch {
+        // ignore log errors
+    }
+    console.log(message);
+}
+// ─── JWT decode ──────────────────────────────────────────────────────────
+export function decodeJwt(token) {
+    try {
+        const payload = token.split(".")[1];
+        const decoded = Buffer.from(payload.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf-8");
+        return JSON.parse(decoded);
+    }
+    catch {
+        return null;
+    }
+}
+export function getPositionIdFromToken(token) {
+    const payload = decodeJwt(token.access_token);
+    return payload?.sub ?? null;
+}

package/dist/daily-submit.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/daily-submit.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * Daily auto-submit entry point (used by launchd/Task Scheduler/cron).
+ * Skips weekends. Auto re-logins if token expired.
+ */
+import { dailySubmit } from "./submit.js";
+dailySubmit().then((ok) => {
+    process.exit(ok ? 0 : 1);
+});

package/dist/discover-position.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Discover the user's internship position ID by capturing API calls.
+ * Tries headless first, falls back to headed browser for manual login.
+ */
+export declare function discoverPosition(): Promise<boolean>;