@aria_asi/cli 0.2.0

package/src/auth-commands.ts

@@ -0,0 +1,175 @@
+import { loadLicense, saveLicense } from './auth.js';
+import { harnessClient } from './harness-client.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+
+const LICENSE_PATH = path.join(homedir(), '.aria', 'license.json');
+
+interface LicenseClaims {
+  jti: string;
+  sub: string;
+  tier: string;
+  exp: number;
+  iat: number;
+}
+
+interface LoginResult {
+  ok: boolean;
+  tier?: string;
+  jti?: string;
+  expiresAt?: string;
+  error?: string;
+}
+
+interface StatusResult {
+  loggedIn: boolean;
+  jti?: string;
+  tier?: string;
+  expiresAt?: string;
+  revoked?: boolean;
+}
+
+interface LogoutResult {
+  ok: boolean;
+}
+
+interface RevokeResult {
+  ok: boolean;
+  jti?: string;
+  error?: string;
+}
+
+export async function login(token: string): Promise<LoginResult> {
+  try {
+    // Validate token via heartbeat; if unverified, issue endpoint
+    let response;
+    try {
+      response = await harnessClient.get('/api/license/heartbeat', {
+        headers: { Authorization: `Bearer ${token}` },
+      });
+    } catch {
+      // If heartbeat fails (unverified token), try issue
+      response = await harnessClient.post('/api/license/issue', {
+        body: { token },
+      });
+    }
+
+    if (!response.ok) {
+      const errBody = await response.json().catch(() => ({}));
+      return { ok: false, error: errBody.error || 'Login failed' };
+    }
+
+    const body = await response.json();
+    const claims: LicenseClaims = body.claims || body;
+
+    // Persist to ~/.aria/license.json with mode 0600
+    const dir = path.dirname(LICENSE_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    fs.writeFileSync(LICENSE_PATH, JSON.stringify(claims, null, 2), {
+      mode: 0o600,
+      encoding: 'utf-8',
+    });
+
+    return {
+      ok: true,
+      tier: claims.tier,
+      jti: claims.jti,
+      expiresAt: new Date(claims.exp * 1000).toISOString(),
+    };
+  } catch (err: any) {
+    return { ok: false, error: err.message || 'Unexpected error during login' };
+  }
+}
+
+export async function status(): Promise<StatusResult> {
+  try {
+    const license = await loadLicense();
+    if (!license || !license.jti) {
+      return { loggedIn: false };
+    }
+
+    // Verify with server
+    const response = await harnessClient.get('/api/license/heartbeat', {
+      headers: { Authorization: `Bearer ${license.jti}` },
+    });
+
+    if (response.status === 410) {
+      // Gone = revoked
+      return {
+        loggedIn: true,
+        jti: license.jti,
+        tier: license.tier,
+        expiresAt: license.exp ? new Date(license.exp * 1000).toISOString() : undefined,
+        revoked: true,
+      };
+    }
+
+    if (!response.ok) {
+      return { loggedIn: false };
+    }
+
+    const body = await response.json();
+    const claims: LicenseClaims = body.claims || body;
+
+    return {
+      loggedIn: true,
+      jti: claims.jti,
+      tier: claims.tier,
+      expiresAt: new Date(claims.exp * 1000).toISOString(),
+      revoked: false,
+    };
+  } catch {
+    // Offline / unreachable — show local state
+    const license = await loadLicense();
+    if (!license || !license.jti) {
+      return { loggedIn: false };
+    }
+    return {
+      loggedIn: true,
+      jti: license.jti,
+      tier: license.tier,
+      expiresAt: license.exp ? new Date(license.exp * 1000).toISOString() : undefined,
+      revoked: undefined, // unknown
+    };
+  }
+}
+
+export async function logout(): Promise<LogoutResult> {
+  try {
+    if (fs.existsSync(LICENSE_PATH)) {
+      fs.unlinkSync(LICENSE_PATH);
+    }
+    return { ok: true };
+  } catch {
+    // Best-effort; file may not exist
+    return { ok: true };
+  }
+}
+
+export async function revoke(reason?: string): Promise<RevokeResult> {
+  try {
+    const license = await loadLicense();
+    if (!license || !license.jti) {
+      return { ok: false, error: 'No active license to revoke' };
+    }
+
+    const response = await harnessClient.post('/api/license/revoke', {
+      body: { jti: license.jti, reason: reason || 'User-initiated revocation', revokedBy: 'self' },
+    });
+
+    if (!response.ok) {
+      const errBody = await response.json().catch(() => ({}));
+      return { ok: false, error: errBody.error || 'Revocation failed' };
+    }
+
+    // Clear local state
+    await logout();
+
+    return { ok: true, jti: license.jti };
+  } catch (err: any) {
+    return { ok: false, error: err.message || 'Unexpected error during revocation' };
+  }
+}

package/src/auth.ts

@@ -0,0 +1,33 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import type { AuthConfig } from './types.js';
+
+const LICENSE_PATH = join(homedir(), '.aria', 'license.json');
+
+/**
+ * Load license configuration from ~/.aria/license.json.
+ * Returns null if the file does not exist or cannot be parsed.
+ */
+export async function loadLicense(): Promise<AuthConfig | null> {
+  try {
+    const raw = await readFile(LICENSE_PATH, 'utf-8');
+    const parsed: AuthConfig = JSON.parse(raw);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persist license configuration to ~/.aria/license.json (mode 0600).
+ * Creates ~/.aria/ directory if missing.
+ */
+export async function saveLicense(config: AuthConfig): Promise<void> {
+  const dir = dirname(LICENSE_PATH);
+  await mkdir(dir, { recursive: true, mode: 0o700 });
+  await writeFile(LICENSE_PATH, JSON.stringify(config, null, 2), {
+    mode: 0o600,
+    encoding: 'utf-8',
+  });
+}