threadlog 0.1.0

package/dist/thread/canonical.js

@@ -0,0 +1,50 @@
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+import { redactSensitiveText } from "../redaction/redact.js";
+export async function buildRedactedRawEventArrayFromJsonl(filePath) {
+    const events = [];
+    const reader = createInterface({
+        input: createReadStream(filePath, { encoding: "utf8" }),
+        crlfDelay: Infinity,
+    });
+    let lineIndex = 0;
+    for await (const rawLine of reader) {
+        const line = rawLine.trim();
+        if (!line) {
+            continue;
+        }
+        const parsed = parseJsonLine(line, lineIndex + 1);
+        events.push(redactJsonValue(parsed));
+        lineIndex += 1;
+    }
+    if (events.length === 0) {
+        throw new Error("session file does not contain any JSONL events");
+    }
+    return events;
+}
+function parseJsonLine(line, lineNumber) {
+    try {
+        return JSON.parse(line);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "invalid JSON";
+        throw new Error(`invalid JSONL at line ${lineNumber}: ${message}`);
+    }
+}
+function redactJsonValue(value) {
+    if (typeof value === "string") {
+        return redactSensitiveText(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => redactJsonValue(item));
+    }
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    const input = value;
+    const output = {};
+    for (const [key, item] of Object.entries(input)) {
+        output[key] = redactJsonValue(item);
+    }
+    return output;
+}

package/dist/upload/artifact.js

@@ -0,0 +1,14 @@
+import { createHash } from "node:crypto";
+import { gzipSync } from "node:zlib";
+export function buildUploadArtifact(rawArtifact) {
+    const payloadBytes = Buffer.from(JSON.stringify(rawArtifact), "utf8");
+    const gzippedBytes = gzipSync(payloadBytes);
+    const sha256Hex = createHash("sha256").update(gzippedBytes).digest("hex");
+    return {
+        bytes: gzippedBytes,
+        sizeBytes: gzippedBytes.byteLength,
+        sha256Hex,
+        contentType: "application/json",
+        contentEncoding: "gzip",
+    };
+}

package/dist/upload/client.js

@@ -0,0 +1,114 @@
+export class UploadRequestError extends Error {
+    status;
+    code;
+    constructor(status, message, code) {
+        super(message);
+        this.name = "UploadRequestError";
+        this.status = status;
+        this.code = code;
+    }
+}
+export function createUploadClient(config) {
+    const authHeader = `Bearer ${config.token}`;
+    return {
+        async createAndUploadArtifact(input) {
+            const createRequest = {
+                contentType: input.artifact.contentType,
+                contentEncoding: input.artifact.contentEncoding,
+                sizeBytes: input.artifact.sizeBytes,
+                sha256Hex: input.artifact.sha256Hex,
+            };
+            const createResponse = await requestJson({
+                apiOrigin: config.apiOrigin,
+                path: "/v1/thread-uploads",
+                method: "POST",
+                authorization: authHeader,
+                body: createRequest,
+            });
+            await uploadToSignedUrl({
+                uploadUrl: createResponse.uploadUrl,
+                requiredHeaders: createResponse.requiredHeaders,
+                bytes: input.artifact.bytes,
+            });
+            const completeRequest = {
+                source: input.source,
+                title: input.title,
+                externalThreadId: input.externalThreadId,
+                capturedAt: input.capturedAt,
+            };
+            const completeResponse = await requestJson({
+                apiOrigin: config.apiOrigin,
+                path: `/v1/thread-uploads/${createResponse.uploadId}/complete`,
+                method: "POST",
+                authorization: authHeader,
+                body: completeRequest,
+            });
+            validateImportState(completeResponse.importState);
+            return completeResponse;
+        },
+    };
+}
+async function uploadToSignedUrl(params) {
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(params.requiredHeaders)) {
+        headers.set(name, String(value));
+    }
+    const response = await fetch(params.uploadUrl, {
+        method: "PUT",
+        headers,
+        body: Buffer.from(params.bytes),
+    });
+    if (response.status !== 200 && response.status !== 204) {
+        throw new Error(`artifact upload failed with status ${response.status}`);
+    }
+}
+async function requestJson(input) {
+    const url = new URL(input.path, `${input.apiOrigin.replace(/\/$/, "")}/`);
+    const headers = new Headers({
+        authorization: input.authorization,
+    });
+    let body;
+    if (input.body !== undefined) {
+        headers.set("content-type", "application/json");
+        body = JSON.stringify(input.body);
+    }
+    const response = await fetch(url, {
+        method: input.method,
+        headers,
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        let message = `request failed (${response.status})`;
+        let code;
+        const contentType = response.headers.get("content-type") ?? "";
+        if (contentType.includes("application/json") && responseBody.trim().length > 0) {
+            try {
+                const parsed = JSON.parse(responseBody);
+                if (typeof parsed.message === "string" && parsed.message.trim().length > 0) {
+                    message = parsed.message.trim();
+                }
+                if (typeof parsed.code === "string" && parsed.code.trim().length > 0) {
+                    code = parsed.code.trim();
+                }
+            }
+            catch {
+                message = `${message}: ${responseBody}`;
+            }
+        }
+        else if (responseBody.trim().length > 0) {
+            message = `${message}: ${responseBody}`;
+        }
+        throw new UploadRequestError(response.status, message, code);
+    }
+    if (!responseBody) {
+        return undefined;
+    }
+    return JSON.parse(responseBody);
+}
+function validateImportState(state) {
+    const allowedStates = ["queued", "processing", "ready", "failed"];
+    if (!allowedStates.includes(state)) {
+        throw new Error(`unexpected import state: ${state}`);
+    }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "threadlog",
+  "version": "0.1.0",
+  "description": "CLI for uploading local Codex and Claude sessions to Threadlog.",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "bin": {
+    "threadlog": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "homepage": "https://www.threadlog.dev",
+  "bugs": {
+    "url": "https://github.com/SerCeMan/threadlog/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SerCeMan/threadlog.git"
+  },
+  "keywords": [
+    "threadlog",
+    "cli",
+    "codex",
+    "claude",
+    "threads",
+    "developer-tools"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc --project tsconfig.build.json",
+    "lint": "pnpm run typecheck",
+    "prepack": "npm run build",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.10.1",
+    "commander": "^14.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.4.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  }
+}