@voidlabs.gg/voidshift-agents 0.4.2 → 0.4.4

package/dist/voidtrack.js

@@ -0,0 +1,89 @@
+// VoidTrack over its REST API with a bearer key. Self hosted installs set
+// VOIDTRACK_API_URL; the web app lives at the same address without /api.
+const apiBase = () => (process.env.VOIDTRACK_API_URL ?? 'https://web.voidtrack.app/api').replace(/\/$/, '');
+// One branch per card that survives a retitle: GitHub closes a pull request
+// whose branch is renamed.
+export const branchFor = (identifier) => identifier.toLowerCase();
+export function mapIssue(i, web) {
+    return {
+        id: i.id,
+        identifier: i.identifier,
+        title: i.title,
+        description: i.description ?? undefined,
+        url: `${web}/issue/${i.identifier}`,
+        branchName: branchFor(i.identifier),
+        teamId: i.team?.id ?? '',
+        teamKey: i.team?.key ?? i.identifier.split('-')[0],
+        projectName: i.project?.name ?? undefined,
+        labels: (i.labels ?? []).map((l) => (typeof l === 'string' ? l : l.name)),
+    };
+}
+export function createVoidTrack(apiKey, fetcher = fetch) {
+    const base = apiBase();
+    const web = base.replace(/\/api$/, '');
+    async function call(method, path, body) {
+        let res;
+        try {
+            res = await fetcher(`${base}${path}`, {
+                method,
+                signal: AbortSignal.timeout(30_000),
+                headers: { Authorization: `Bearer ${apiKey}`, ...(body === undefined ? {} : { 'Content-Type': 'application/json' }) },
+                body: body === undefined ? undefined : JSON.stringify(body),
+            });
+        }
+        catch (err) {
+            const cause = err.cause;
+            throw new Error(`could not reach VoidTrack (${cause?.code ?? cause?.message ?? err.message})`);
+        }
+        const text = await res.text();
+        if (!res.ok)
+            throw Object.assign(new Error(`voidtrack ${method} ${path.split('?')[0]} ${res.status}: ${text.slice(0, 200)}`), { status: res.status });
+        return text ? JSON.parse(text) : {};
+    }
+    const enc = encodeURIComponent;
+    return {
+        async viewer() {
+            const d = await call('GET', '/v1/users');
+            const me = (d.users ?? []).find((u) => u.isMe);
+            if (!me)
+                throw new Error('voidtrack did not say which user this key belongs to');
+            return { id: me.id, name: me.name };
+        },
+        // My open cards in the team carrying the label. The API cannot filter on
+        // labels, so that part happens here.
+        async myCardsWithLabel(label, team) {
+            const d = await call('GET', `/v1/issues?team=${enc(team)}&assignee=me&stateType=backlog,unstarted,started&sort=created&limit=200`);
+            return (d.issues ?? []).map((i) => mapIssue(i, web)).filter((c) => c.labels.includes(label));
+        },
+        async card(identifier) {
+            const d = await call('GET', `/v1/issues/${enc(identifier)}`);
+            if (!d.issue)
+                throw new Error(`voidtrack has no card ${identifier}`);
+            return mapIssue(d.issue, web);
+        },
+        async comments(identifier) {
+            const d = await call('GET', `/v1/issues/${enc(identifier)}/comments`);
+            return (d.comments ?? []).map((c) => ({ body: c.body, createdAt: c.createdAt }));
+        },
+        async comment(card, body) {
+            await call('POST', `/v1/issues/${enc(card.identifier)}/comments`, { body });
+        },
+        // Labels are free text on VoidTrack and the list replaces the whole set.
+        async setLabels(card, next) {
+            await call('PATCH', `/v1/issues/${enc(card.identifier)}`, { labels: next });
+            card.labels = next;
+        },
+        // Move to a named state; false if the team has no such state.
+        async moveTo(card, stateName) {
+            try {
+                await call('PATCH', `/v1/issues/${enc(card.identifier)}`, { state: stateName });
+                return true;
+            }
+            catch (err) {
+                if (err.status === 400 || err.status === 404)
+                    return false;
+                throw err;
+            }
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voidlabs.gg/voidshift-agents",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Agents for Claude Code and Codex that plan, build and QA Linear cards, chained and run in the background.",
   "license": "Apache-2.0",
   "repository": {
@@ -18,7 +18,8 @@
     "agents",
     "linear",
     "cli",
-    "macos"
+    "macos",
+    "linux"
   ],
   "type": "module",
   "main": "dist/index.js",
@@ -29,9 +30,6 @@
     "LICENSE",
     "README.md"
   ],
-  "os": [
-    "darwin"
-  ],
   "engines": {
     "node": ">=22.18"
   },

package/dist/keychain.d.ts

@@ -1,3 +0,0 @@
-export declare function readLinearKey(): string | null;
-export declare const looksLikeLinearKey: (key: string) => boolean;
-export declare function storeLinearKey(key: string): boolean;

package/dist/keychain.js

@@ -1,19 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { userInfo } from 'node:os';
-const SERVICE = 'voidshift-linear';
-const KEY_SHAPE = /^lin_api_[A-Za-z0-9]+$/;
-export function readLinearKey() {
-    const r = spawnSync('/usr/bin/security', ['find-generic-password', '-s', SERVICE, '-w'], { encoding: 'utf8' });
-    const key = r.status === 0 ? r.stdout.trim() : '';
-    return key || null;
-}
-export const looksLikeLinearKey = (key) => KEY_SHAPE.test(key);
-// Stores the key through `security -i` on stdin, so it never appears in a
-// process list. The shape check above rules out anything that could break
-// out of the command line.
-export function storeLinearKey(key) {
-    if (!looksLikeLinearKey(key))
-        return false;
-    const command = `add-generic-password -U -s ${SERVICE} -a ${userInfo().username} -w ${key}\n`;
-    return spawnSync('/usr/bin/security', ['-i'], { input: command, encoding: 'utf8' }).status === 0;
-}