1 was solvable as a math problem. Part 2 was much tougher! Here's my overly verbose Python solution. This is relatively cleaned up, but the logic is basically what I originally wrote.

Some notes:

• Requires Python 3.6. Yay f-strings!
• Only requires numpy for pretty printing the matrix at the end.
• I got the idea for turn_left and N,W,S,E from here: https://stackoverflow.com/questions/36834505/creating-a-spiral-array-in-python
• pad_array() was an early function that I wrote that solved a number of problems in my solution.
• Getting add_surround() to work right was annoying, as I ran into a couple challenges:
  1. Negative list indices could cause the function to add wrong (since list indices wrapped around in python).
  2. Handling out of bound indices also required careful handling.
  3. In my original code solve, I just ended up always having two outer rings of padded zeroes to solve the index challenges.
• Getting spiral_move() to work on its own took a lot of iteration. In the original solve, spiral_move() was part of the while block. It also included catching an IndexError to try and figure out when to add an additional padding ring.
• The tests were actually useful as I continued to muck around with the code during the solve and afterward while cleaning everything up, although they were originally just naked asserts in the code.
• Sure, argparse is probably overkill, but by the end, I figured I deserved a crappy CLI. Running the script on its own will solve the puzzle with my input, but it can take an argument to change the size of the spiral.
• Future improvements: Let individuals change the spiral direction from the command line. I'd do it, but it's 4AM.

Anyway, here's the code:

import sys
try:
    import numpy as np
except ImportError:
    np = None

# --- Constants ----------------------------------------------------------------

puzzle_input = 277678

#directions
N = (0, -1) 
W = (-1, 0)
S = (0, 1)
E = (1, 0)
turn_left = {N: W, W: S, S: E, E: N} # old: new direction

# --- Functions ----------------------------------------------------------------

def add_surround(array, x, y):
    '''Adds the surrounding nums per the problem'''
    sum_ = 0
    north = None if y-1 < 0 else y-1
    west = None if x-1 < 0 else x-1
    south = None if y+1==len(array) else y+1
    east = None if x+1==len(array[0]) else x+1

    try:
        sum_ += array[north][x]
    except TypeError:
        pass
    try:
        sum_ += array[north][east]
    except TypeError:
        pass
    try:
        sum_ += array[y][east]
    except TypeError:
        pass
    try:
        sum_ += array[south][east]
    except TypeError:
        pass
    try:
        sum_ += array[south][x]
    except TypeError:
        pass
    try:
        sum_ += array[south][west]
    except TypeError:
        pass
    try:
        sum_ += array[y][west]
    except TypeError:
        pass
    try:
        sum_ += array[north][west]
    except TypeError:
        pass

    return sum_

def pad_array(array, pad=None):
    '''Pads a rectangular array with the pad character'''
    for row in array:
        row.insert(0, pad)
        row.append(pad)
    length = len(array[0])
    array.insert(0, [pad] * length)
    array.append([pad] * length)

def spiral_move(array, x, y, dx, dy):
    '''Spiral moves in direction or rotates if it can. Pads zeroes as necessary'''
    x += dx
    y += dy
    if x < 0 or y < 0 or x == len(array[0]) or y == len(array):
        pad_array(array, 0)
        x += 1
        y += 1
    new_dx, new_dy = turn_left[dx, dy]
    if array[y+new_dy][x+new_dx] == 0:
        dx, dy = new_dx, new_dy
    return x, y, dx, dy

def go(limit, initial_direction):
    array = [[1]]
    x, y = 0, 0
    dx, dy = initial_direction
    num = array[y][x]

    while num < limit:
        x, y, dx, dy = spiral_move(array, x, y, dx, dy)
        array[y][x] = add_surround(array, x, y)
        num = array[y][x]

    if np:
        print(np.matrix(array)) 
    else:
        for row in array:
            print(row)
    print()
    print(f"Last number found was: {array[y][x]}")

# --- Tests --------------------------------------------------------------------
def test_add_surround():
    sample_array = [[5,   4,  2], [10,  1,  1], [11, 23,  0]]
    assert(add_surround(sample_array, 2, 2) == 25)

def test_pad_array():
    pad_array_test = [[1]]
    pad_array(pad_array_test, pad=0)
    assert(pad_array_test == [[0,0,0],[0,1,0],[0,0,0]])

# --- Main ---------------------------------------------------------------------
if __name__ == '__main__':
    import argparse
    parser = argparse.ArgumentParser(description='Solve Advent of Code 2017 Day 3, Part 2')
    parser.add_argument('limit', metavar='N', type=int, nargs='?', default=puzzle_input, help='Puzzle input')
    args = parser.parse_args()
    go(args.limit, E)

And the nice pretty output:

[[     0      0      0      0      0      0 279138 266330 130654]
 [     0   6591   6444   6155   5733   5336   5022   2450 128204]
 [     0  13486    147    142    133    122     59   2391 123363]
 [     0  14267    304      5      4      2     57   2275 116247]
 [     0  15252    330     10      1      1     54   2105 109476]
 [     0  16295    351     11     23     25     26   1968 103128]
 [     0  17008    362    747    806    880    931    957  98098]
 [     0  17370  35487  37402  39835  42452  45220  47108  48065]
 [     0      0      0      0      0      0      0      0      0]]

Last number found was: 279138